def post_reply(request, topic_id):
form = PostForm()
topic = Topic.objects.get(pk=topic_id)
user = request.user
if topic.closed:
return render(request, 'personal/basic.html', {'content':['This topic is closed.']})
if topic.forum.closed and not user.has_perm('forum.can_post_lock_forum'):
return render(request, 'personal/basic.html', {'content':['This forum is locked.']})
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = 'RE: '+topic.title
post.body = bleach_clean(form.cleaned_data['body'])
post.creator = request.user
post.user_ip = get_client_ip(request)
post.save()
return HttpResponseRedirect(reverse('topic-detail', args=(topic.id, topic.slug, )))
return render_to_response('forum/reply.html', {
'form': form,
'topic': topic,
'forum': topic.forum,
'editing': False,
}, context_instance=RequestContext(request))
def reply_topic(request, category_slug, topic_slug):
topic = get_object_or_404(Topic,
category__slug=category_slug,
slug=topic_slug)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.topic = topic
post.updated_by = request.user
post.save()
topic.last_updated = timezone.now()
topic.save()
topic_url = reverse('posts_of_topic',
kwargs={
'category_slug': category_slug,
'topic_slug': topic_slug
})
topic_post_url = '{url}?page={page}#{id}'.format(
url=topic_url, id=post.pk, page=topic.get_page_count())
return redirect(topic_post_url)
else:
form = PostForm()
return render(request, 'forum/reply_topic.html', {
'topic': topic,
'form': form
})
def edit_post(request, postId):
try:
post = Post.objects.get(id=postId)
except Post.DoesNotExist:
raise Http404("Post doesn't exist.")
if request.user != post.user and not request.user.has_moderator_rights():
return HttpResponseForbidden("Not your post (and not a moderator).")
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
text = form.cleaned_data['text']
post.text = text
post.was_edited = True
post.date_edited = timezone.localtime(timezone.now())
post.edited_by = request.user
post.save()
return HttpResponseRedirect(post.get_url())
else:
form = PostForm(initial={'text': post.text})
context = {'form': form, 'post': post}
return render(request, 'edit/edit_post.html', context)
def post_reply(request, slug, topic_id):
quote = request.GET.get('quote', '')
author = request.GET.get('author', '')
if quote:
quote = '<blockquote>' + quote + '<footer>' + author + '</footer></blockquote>'
forum = get_object_or_404(Forum, slug=slug)
posts = Post.objects.filter(topic=topic_id).order_by("created").reverse()[:3]
topic = Topic.objects.get(pk=topic_id)
form_title = ''
if topic.last_post():
form_title = 'Re: ' + topic.last_post().title.replace('Re: ', '')
default_data = {'title': form_title}
form = PostForm(initial=default_data)
if request.method == 'POST':
quote = request.POST.get('quote', '')
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = form.cleaned_data['title']
post.body = quote + form.cleaned_data['body']
post.creator = request.user
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return HttpResponseRedirect(reverse('topic-detail', args=(slug, topic.id, )))
return render(request, 'forum/reply.html', {'form': form, 'topic': topic, 'forum': forum, 'posts': posts, 'quote': quote})
def post_reply_edit(request, post_id):
post = Post.objects.get(pk=post_id)
topic = post.topic
user = request.user
form = PostForm(instance=post)
if not user.id == post.creator.id:
return render(request, 'personal/basic.html', {'content':['You do not own this post.']})
if topic.closed:
return render(request, 'personal/basic.html', {'content':['This topic is closed.']})
if topic.forum.closed and not user.has_perm('forum.can_post_lock_forum'):
return render(request, 'personal/basic.html', {'content':['This forum is locked.']})
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
post.body = bleach_clean(form.cleaned_data['body'])
post.save()
return HttpResponseRedirect(reverse('topic-detail', args=(topic.id, topic.slug, )))
return render_to_response('forum/reply.html', {
'form': form,
'topic': topic,
'forum': topic.forum,
'editing': True,
}, context_instance=RequestContext(request))
def newthread(request, cat_id):
if not request.user.is_authenticated():
return redirect(reverse(index))
else:
try:
cat = Category.objects.get(pk=cat_id)
except Category.DoesNotExist:
return redirect(reverse(ticket))
if request.method == 'POST':
tform = ThreadForm(request.POST, prefix="thd")
pform = PostForm(request.POST, prefix="pst")
if tform.is_valid() and pform.is_valid():
date = datetime.datetime.now()
newt = tform.save(commit=False)
newt.rank = 0
newt.parent = cat
newt.date = date
newt.save()
newp = pform.save(commit=False)
newp.author = request.user
newp.date = date
newp.parent = newt
newp.save()
url = ''.join(('/agora/', str(cat_id), '/', str(newt.id), '/'))
return redirect(url, request)
else:
tform = ThreadForm(prefix="thd")
pform = PostForm(prefix="pst")
return render(request, 'newthread.html', locals())
def post_reply(request, topic_id):
form = PostForm()
topic = Topic.objects.get(pk=topic_id)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = form.cleaned_data['title']
post.body = form.cleaned_data['body']
post.creator = request.user
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return HttpResponseRedirect(
reverse('topic-detail', args=(topic.id, )))
return render_to_response('django_simple_forum/reply.html', {
'form': form,
'topic': topic,
},
context_instance=RequestContext(request))
def add_post(request, post_id=None):
if post_id:
post = get_object_or_404(Post, pk=post_id)
if post.author != request.user:
return HttpResponseForbidden("Only owner of this post is allowed to edit")
else:
post = Post(author=request.user)
if request.method == 'POST': # If the form has been submitted...
form = PostForm(request.POST, instance=post) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
text = form.cleaned_data['content']
html = markdown(text)
post.title = form.cleaned_data['title']
post.content = html
post.tagnames = form.cleaned_data['tagnames']
post.save()
return HttpResponseRedirect('/')
else:
# An unbound form
form = PostForm(instance=post)
return render(request, 'new_post.html', {
'form': form,
'post_id': post_id,
})
def _topic_create_POST(request):
commit = True
try:
post = Post(author=request.forum_user)
post_form = PostForm(request.POST, instance=post)
if post_form.is_valid():
post = post_form.save()
topic = Topic(author=request.forum_user, first_post=post,
last_post=post)
topic_form = TopicForm(request.POST, instance=topic)
if topic_form.is_valid():
topic = topic_form.save()
post.topic = topic
post.save()
for category in topic.categories.all():
category.topic_count = category.topic_set.all().count()
category.post_count = Post.objects\
.filter(topic__in=category.topic_set.all()).count()
category.save()
return redirect(post.get_absolute_url())
else:
post_form = PostForm(request.POST)
ctx = {
'forum_user': request.forum_user,
'topic_form': topic_form,
'post_form': post_form,
}
return render(request, 'forum/topic/create.html', ctx)
finally:
if commit:
transaction.commit()
else:
transaction.rollback()
def new_post(request, thread_id):
thread = get_object_or_404(Thread, pk=thread_id)
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(False)
post.thread = thread
post.user = request.user
post.save()
messages.success(request, "Your post has been added to the topic")
return redirect(reverse('forum_thread', args={thread.pk}))
else:
form = PostForm()
args = {
'form': form,
'form_action': reverse('forum_new_post', args={thread.id}),
'button_text': 'Update post'
}
args.update(csrf(request))
return render(request, 'forum/post_form.html', args)
def new_post(request, pk):
context = RequestContext(request)
context_dict = {'pk': pk}
context_dict['action'] = 'new_thread'
forum = Forum.objects.get(pk=pk)
context_dict['forum_title'] = forum.title
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
body = form.cleaned_data['body']
thread = Thread.objects.create(forum=forum,
title=subject,
creator=request.user)
Post.objects.create(thread=thread,
subject=subject,
body=body,
creator=request.user)
#return HttpResponse('Your Thread has been created')
return HttpResponseRedirect(
reverse("forum.views.threadlist", args=[pk]))
else:
print form.errors
else:
return render_to_response('forum/newpost.html', context_dict, context)
def new_post_view(request, thread_id):
doge_user = DogeUser.objects.get(user=request.user)
form = PostForm(data=request.POST)
thread = get_object_or_404(Thread, pk=thread_id)
if form.is_valid():
form.create_post(doge_user, thread)
return thread_redirect(thread_id)
return HttpResponseRedirect(reverse('index'))
def post_reply(request, topic_id):
form = PostForm()
topic = Topic.objects.get(pk=topic_id)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = form.cleaned_data['title']
post.body = form.cleaned_data['body']
post.creator = request.user
userToUpdate = UserProfile.objects.get(user=request.user)
nCredits = userToUpdate.credits
userToUpdate.credits = int(float(nCredits + 100))
# TODO: Change status (if points+100>threshold -> status changes) Alert???
# Alert? Maybe return to page with status update info for user.
# Make Gold/Platinum distinction
if nCredits + 100 >= GOLD_THRESHOLD:
newStatus = "Gold"
userToUpdate.status = newStatus
userToUpdate.save()
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return render_to_response(
"forum/status_change.html", {'status': newStatus},
context_instance=RequestContext(request))
elif nCredits + 100 >= PLATINUM_THRESHOLD:
newStatus = "Platinum"
userToUpdate.status = newStatus
userToUpdate.save()
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return render_to_response(
"forum/status_change.html", {'status': newStatus},
context_instance=RequestContext(request))
else:
userToUpdate.save()
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return HttpResponseRedirect(
reverse('topic-detail', args=(topic.id, )))
return render_to_response('forum/reply.html', {
'form': form,
'topic': topic,
},
context_instance=RequestContext(request))
def post(self, *args, **kwargs):
user = self.request.user
form = PostForm(self.request.POST or None)
if form.is_valid():
author = user
title = form.cleaned_data.get('title')
text = form.cleaned_data.get('text')
post = Post(author=author, title=title, text=text)
post.save()
messages.success(self.request, "Your post has been added to your drafts but it has not been published yet")
return redirect('post_draft_list', username=user.username)
def addpost(request, section_id, topic_id):
form = PostForm(request.POST or None)
if form.is_valid():
post = form.save(commit=False)
post.topic = get_object_or_404(Topic, pk=topic_id)
post.timestamp = datetime.today()
post.author = request.user.username
post.save()
return redirect(posts, section_id, topic_id)
def create_post(request):
if request.method == "POST":
form = PostForm(request.POST, request.FILES)
if form.is_valid():
p = form.save(commit=False)
p.user = request.user
p.save()
return redirect('/forum/')
else:
form = PostForm()
args = {'form': form}
return render(request, 'forum/create.html', args)
def submit_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
f = form.save(commit = False)
if request.user.is_authenticated():
f.author = request.user
f.save()
return HttpResponseRedirect('/forum/post/' + f.slug + '/')
else:
form = PostForm()
return render(request, 'forum/submit_post.html',{'form': form})
def post_list(request, template='post/list.html'):
d = {}
d['form'] = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
item = form.save()
return JsonResponse(data={'id': item.id, 'name': str(item), 'form': PostForm().as_p(), 'token': get_token(request)})
else:
d['form'] = form
return JsonResponse(data={'form': d['form'].as_p(), 'token': get_token(request)}, success=False)
d['post_list'] = Post.objects.all()
return render(request, template, d)
def post_details(request, id, template='post/details.html'):
d = {}
item = get_object_or_404(Post, pk=id)
d['form'] = PostForm(instance=item)
if request.method == 'POST':
form = PostForm(request.POST, instance=item)
if form.is_valid():
item = form.save()
return JsonResponse(data={'form': PostForm(instance=item).as_p(), 'token': get_token(request)})
else:
d['form'] = form
return JsonResponse(data={'form': d['form'].as_p(), 'token': get_token(request)}, success=False)
d['post'] = Post.objects.get(pk=id)
return render(request, template, d)
def open_thread(request, threadSlug, page=0):
try:
theThread = Thread.objects.get(slug=threadSlug)
except Thread.DoesNotExist:
raise Http404("Thread doesn't exist.")
if request.method == 'POST' and not theThread.is_locked:
form = PostForm(request.POST)
if form.is_valid():
text = form.cleaned_data['text']
newPost = Post(sub_forum=theThread.sub_forum,
thread=theThread,
user=request.user,
text=text)
newPost.save()
return HttpResponseRedirect(newPost.get_url())
else:
form = PostForm()
postPerPage = settings.POSTS_PER_PAGE
page = int(page)
startPost = page * postPerPage
allPosts = theThread.post_set.all()
totalPosts = allPosts.count()
totalPages = int(math.ceil(float(totalPosts) / float(postPerPage)))
if page != 0 and startPost >= totalPosts:
raise Http404("Invalid thread page.")
pagePosts = allPosts[startPost:startPost + postPerPage]
context = {
'thread': theThread,
'posts': pagePosts,
'threadSlug': threadSlug,
'page': page,
'pages': range(0, totalPages),
'form': form,
'paths': [theThread.sub_forum, theThread]
}
utilities.get_message(request, context)
return render(request, 'thread.html', context)
def post_reply(request, topic_id):
form = PostForm()
topic = Topic.objects.get(pk=topic_id)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = form.cleaned_data['title']
post.body = form.cleaned_data['body']
post.creator = request.user
userToUpdate = UserProfile.objects.get(user=request.user)
nCredits = userToUpdate.credits
userToUpdate.credits = int(float(nCredits + 100))
# TODO: Change status (if points+100>threshold -> status changes) Alert???
# Alert? Maybe return to page with status update info for user.
# Make Gold/Platinum distinction
if nCredits + 100 >= GOLD_THRESHOLD:
newStatus = "Gold"
userToUpdate.status = newStatus
userToUpdate.save()
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return render_to_response("forum/status_change.html", {'status': newStatus}, context_instance=RequestContext(request))
elif nCredits + 100 >= PLATINUM_THRESHOLD:
newStatus = "Platinum"
userToUpdate.status = newStatus
userToUpdate.save()
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return render_to_response("forum/status_change.html", {'status': newStatus}, context_instance=RequestContext(request))
else:
userToUpdate.save()
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return HttpResponseRedirect(reverse('topic-detail', args=(topic.id, )))
return render_to_response('forum/reply.html', {
'form': form,
'topic': topic,
}, context_instance=RequestContext(request))
def add_post(request, theme_id):
form = PostForm(request.POST)
if form.is_valid():
create_post(
theme_id,
form.cleaned_data['post'],
request.user.id)
# redirecting to the last page
posts_list = get_list_or_404(Post, theme_id=theme_id)
paginator = Paginator(posts_list, 5)
url = reverse('forum:theme', args=[theme_id, paginator.num_pages])
return HttpResponseRedirect(url)
def addSurvivingPost(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
author = request.user
title = form.cleaned_data['title']
body = form.cleaned_data['body']
post = SurvivingPost.objects.create(title=title,
author=author,
body=body)
return redirect('/forum')
return render(request, 'forum/addPost.html')
def create_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
content = form.cleaned_data['content']
title = form.cleaned_data['title']
post = Post(content=content, title=title, author=request.user)
post.save()
messages.success(request, f'New post created')
return redirect('forum')
else:
form = PostForm()
context = {
'PostForm': PostForm,
}
return render(request, 'forum/post_creation.html', context)
def forum_create(request):
if request.method == 'POST':
form = PostForm(request.POST)
print(form.errors)
if form.is_valid():
cd = form.cleaned_data
post = Post(title=cd['title'],
content=cd['body'],
sender=request.user,
summary=cd['outline'],
category=cd['category'])
post.save()
return HttpResponseRedirect('/forum_index')
else:
form = PostForm()
return render(request, 'forum_create.html', {'form': form})
def post_details(request, id, template="post/details.html"):
"""View for a forum post.
Autogenerated initially."""
d = {}
item = get_object_or_404(Post, pk=id)
d["form"] = PostForm(instance=item)
if request.method == "POST":
form = PostForm(request.POST, instance=item)
if form.is_valid():
item = form.save()
return JsonResponse(data={"form": PostForm(instance=item).as_p(), "token": get_token(request)})
else:
d["form"] = form
return JsonResponse(data={"form": d["form"].as_p(), "token": get_token(request)}, success=False)
d["post"] = Post.objects.get(pk=id)
d["username"] = User.objects.get(id=d["post"].created_by_id).username
return render(request, template, d)
def post_dir(request, thread_id):
thread_info = Thread.objects.get(pk=thread_id)
post_list = Post.objects.filter( thread = thread_id )
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
thread = Post( thread = thread_info )
form = PostForm(request.POST, instance = thread )
form.save()
return HttpResponseRedirect(reverse('forum.views.post_dir', args=(thread_id,)))
else:
form = PostForm()
return render_to_response("post.html",
{'post_list' : post_list,
'thread_info' : thread_info,
'form': form,},
context_instance=RequestContext(request) )
def edit_exercise_view(request, pk):
ex = get_object_or_404(Exercise, pk=pk)
form = PostForm(instance=ex)
if request.method == 'POST':
form = PostForm(request.POST, instance=ex)
if form.is_valid():
form.save()
return HttpResponse('Todo Bien')
else:
return render(request,
'training/ex_post.html',
context={
'form': form,
'errors': form.errors
})
else:
return render(request, 'training/ex_post.html', context={'form': form})
def post(self, request, *args, **kwargs):
form = PostForm(request.POST or None)
print('test2')
print(request.POST)
if form.is_valid():
print('test3')
post_data = Post()
post_data.author = request.user
post_data.title = form.cleaned_data['title']
post_data.text = form.cleaned_data['text']
category = form.cleaned_data['category']
category_data = Category.objects.filter(name=category)[0]
post_data.category = category_data
post_data.save()
print('test')
return redirect('forum:post_detail', post_data.id)
return render(request, 'forum/post_form.html', {'form': form})
def reply(request, pk):
context = RequestContext(request)
context_dict = {'pk': pk}
if request.method=="POST":
form = PostForm(request.POST)
if form.is_valid():
thread = Thread.objects.get(pk=pk)
subject = form.cleaned_data['subject']
body = form.cleaned_data['body']
Post.objects.create(thread=thread, subject=subject, body = body, creator=request.user)
return HttpResponseRedirect(reverse("forum.views.postlist", args=[pk]))
else:
print form.errors
else:
return render_to_response('forum/reply.html', context_dict, context)
def edit_post_view(request, pk):
post = get_object_or_404(Post, pk=pk)
form = PostForm(instance=post)
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return HttpResponse('Todo Bien')
else:
return render(request,
'forum/create_post.html',
context={
'form': form,
'errors': form.errors
})
else:
return render(request,
'forum/create_post.html',
context={'form': form})
def edit_New_view(request, pk):
new = get_object_or_404(Notice, pk=pk)
form = PostForm(instance=new)
if request.method == 'POST':
form = PostForm(request.POST, instance=new)
if form.is_valid():
form.save()
return HttpResponse('Todo Bien')
else:
return render(request,
'news/create_notice.html',
context={
'form': form,
'errors': form.errors
})
else:
return render(request,
'news/create_notice.html',
context={'form': form})
def post_reply(request, topic_id):
form = PostForm()
topic = Topic.objects.get(pk=topic_id)
user = request.user
if topic.closed:
return render(request, 'personal/basic.html',
{'content': ['This topic is closed.']})
if topic.forum.closed and not user.has_perm('forum.can_post_lock_forum'):
return render(request, 'personal/basic.html',
{'content': ['This forum is locked.']})
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = 'RE: ' + topic.title
post.body = bleach_clean(form.cleaned_data['body'])
post.creator = request.user
post.user_ip = get_client_ip(request)
post.save()
return HttpResponseRedirect(
reverse('topic-detail', args=(
topic.id,
topic.slug,
)))
return render_to_response('forum/reply.html', {
'form': form,
'topic': topic,
'forum': topic.forum,
'editing': False,
},
context_instance=RequestContext(request))
def post_reply_edit(request, post_id):
post = Post.objects.get(pk=post_id)
topic = post.topic
user = request.user
form = PostForm(instance=post)
if not user.id == post.creator.id:
return render(request, 'personal/basic.html',
{'content': ['You do not own this post.']})
if topic.closed:
return render(request, 'personal/basic.html',
{'content': ['This topic is closed.']})
if topic.forum.closed and not user.has_perm('forum.can_post_lock_forum'):
return render(request, 'personal/basic.html',
{'content': ['This forum is locked.']})
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
post.body = bleach_clean(form.cleaned_data['body'])
post.save()
return HttpResponseRedirect(
reverse('topic-detail', args=(
topic.id,
topic.slug,
)))
return render_to_response('forum/reply.html', {
'form': form,
'topic': topic,
'forum': topic.forum,
'editing': True,
},
context_instance=RequestContext(request))
def edit_post(request, thread_id, post_id):
thread = get_object_or_404(Thread, pk=thread_id)
post = get_object_or_404(Post, pk=post_id)
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
messages.success(request, "You have updated your post")
return redirect(reverse('forum_thread', args={thread.pk}))
else:
form = PostForm(instance=post)
args = {
'form': form,
'form_action': reverse('forum_edit_post', kwargs={"thread_id": thread.id, "post_id": post.id}),
'button_text': 'Update post'
}
args.update(csrf(request))
return render(request, 'forum/post_form.html', args)
def topic_details(request, id, template="topic/details.html"):
"""View for a forum topic.
Autogenerated initially."""
d = {}
d["form"] = PostForm()
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.topic_id = id
post.created_by_id = 1
post.save()
# return JsonResponse(data={'id': item.id, 'name': str(item), 'form': PostForm().as_p(), 'token': get_token(request)})
else:
d["form"] = form
# return JsonResponse(data={'form': d['form'].as_p(), 'token': get_token(request)}, success=False)
d["topic"] = Topic.objects.get(pk=id)
posts = Post.objects.filter(topic=id)
d["pairs"] = []
for i in posts:
d["pairs"].append([i, User.objects.get(id=i.created_by_id).username])
return render(request, template, d)
def post_reply(request, topic_id):
form = PostForm()
topic = Topic.objects.get(pk=topic_id)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.body = form.cleaned_data['body']
post.creator = request.user
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return HttpResponseRedirect(reverse('forum:topic-detail', args=(topic.id, )))
context = get_base_context()
context.update({'form': form, 'topic': topic})
return render(request, 'forum/reply.html', context)
def new_post(request, pk):
context = RequestContext(request)
context_dict = {'pk':pk}
context_dict['action'] = 'new_thread'
forum = Forum.objects.get(pk=pk)
context_dict['forum_title'] = forum.title
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
body = form.cleaned_data['body']
thread = Thread.objects.create(forum=forum, title=subject, creator=request.user)
Post.objects.create(thread=thread, subject=subject, body=body, creator=request.user)
#return HttpResponse('Your Thread has been created')
return HttpResponseRedirect(reverse("forum.views.threadlist", args=[pk]))
else:
print form.errors
else:
return render_to_response('forum/newpost.html', context_dict, context)
def new_thread(request):
if request.method == "POST":
thread_form = ThreadForm(request.POST)
post_form = PostForm(request.POST)
if thread_form.is_valid() and post_form.is_valid():
thread = thread_form.save()
post = post_form.save(False)
post.thread = thread
post.save()
# else:
# thread_form = ThreadForm()
# post_form = PostForm()
#
#
# args = {}
# args.update(csrf(request))
# args['thread_form'] = thread_form
# args['post_form'] = post_form
return render(request, 'index.html', locals())
def reply(request, pk):
context = RequestContext(request)
context_dict = {'pk': pk}
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
thread = Thread.objects.get(pk=pk)
subject = form.cleaned_data['subject']
body = form.cleaned_data['body']
Post.objects.create(thread=thread,
subject=subject,
body=body,
creator=request.user)
return HttpResponseRedirect(
reverse("forum.views.postlist", args=[pk]))
else:
print form.errors
else:
return render_to_response('forum/reply.html', context_dict, context)
class ForumThreadPage(RoutablePageMixin, Page):
parent_page_types = ['ForumPage']
subpage_types = []
slug = 'threads'
form = PostForm()
thread = None
@route(r'^$')
def thread_list_view(self, request):
return ForumPage().serve(request)
@route(r'^(\d+)/$')
def thread_view(self, request, thread_pk=None):
try:
self.thread = Thread.objects.get(pk=thread_pk)
except Thread.DoesNotExist:
messages.error(request, 'Thread deleted or never existed')
return ForumPage().serve(request)
self.form = PostForm(request.POST or None)
if request.method == 'POST' and self.form.is_valid():
try:
data = self.form.cleaned_data
post = Post(
content=data['content'],
author=request.user,
thread=self.thread
)
post.save()
messages.success(request, 'Your post has been created')
self.form = PostForm(None)
except:
messages.error(request, 'An error occurred during post creation. Please try again later')
return super().serve(request)
def post_create(request, topic_id, slug=None):
topic = get_object_or_404(Topic, id=topic_id, is_closed=False)
is_xhr = bool(request.REQUEST.get('xhr'))
post = Post(topic=topic, author=request.forum_user)
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save()
# update counters
topic.post_count = topic.post_set.all().count()
topic.updated = post.created
topic.save()
for category in topic.categories.all():
category.topic_count = category.topic_set.all().count()
category.post_count = Post.objects\
.filter(topic__in=category.topic_set.all()).count()
category.save()
if is_xhr:
return {
'status': 'ok',
'saved': True,
'url': post.get_absolute_url()
}
return _redirect_next(request, post)
if is_xhr:
return {
'status': 'ok',
'saved': False,
'errors': form.errors(),
}
else:
form = PostForm()
ctx = {'post_form': form, 'topic': topic}
return render(request, 'forum/post/create.html', ctx)
def agora(request, cat_id=None, thd_id=None):
if not request.user.is_authenticated():
return redirect(reverse(main.views.index))
else:
if cat_id:
try:
cat = Category.objects.get(pk=cat_id)
except Category.DoesNotExist:
return redirect(reverse(agora))
name = cat.name
parent = cat.parent_id
cat_list = Category.objects.filter(parent=cat_id)
if thd_id:
msg_list = Post.objects.filter(parent=thd_id)
try:
thd = Thread.objects.get(pk=thd_id)
except Thread.DoesNotExist:
url = ''.join(('/agora/', str(cat_id), '/'))
return redirect(url, request)
tname = thd.name
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
date = datetime.datetime.now()
new = form.save(commit=False)
new.author = request.user
new.date = date
new.parent = thd
new.save()
thd.date = date
thd.save()
else:
form = PostForm()
else:
thd_list = Thread.objects.filter(parent=cat_id)
return render(request, 'agora.html', locals())
def post_reply(request, topic_id):
form = PostForm()
topic = Topic.objects.get(pk=topic_id)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = form.cleaned_data['title']
post.body = form.cleaned_data['body']
post.creator = request.user
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return HttpResponseRedirect(reverse('topic-detail', args=(topic.id, )))
return render_to_response('django_simple_forum/reply.html', {
'form': form,
'topic': topic,
}, context_instance=RequestContext(request))
