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 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 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_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 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 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_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 ticket(request, tkt_id=None):
if not request.user.is_authenticated():
return redirect(reverse(main.views.index))
else:
if tkt_id:
try:
tkt = Ticket.objects.get(pk=tkt_id)
except Ticket.DoesNotExist:
return redirect(reverse(ticket))
if tkt.author != request.user:
return redirect(reverse(ticket))
msg_list = TicketMessage.objects.filter(parent=tkt_id)
if request.method == 'POST':
form = TicketMessafeForm(request.POST)
if form.is_valid():
date = datetime.datetime.now()
new = form.save(commit=False)
new.author = request.user
new.date = date
new.parent = tkt
new.save()
tkt.date = date
tkt.save()
else:
form = PostForm()
else:
tkt_list = Ticket.objects.filter(author=request.user)
return render(request, 'ticket.html', locals())
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 edit_post(request, post_id, topic_id):
post = get_object_or_404(Post, id=post_id)
topic = get_object_or_404(Topic, id=topic_id)
posts = topic.post_set.order_by('date_added')
if post.author != request.user:
raise Http404
if request.method != 'POST':
form = PostForm(instance=post)
else:
form = PostForm(request.POST, instance=post)
new_post = form.save(commit=False)
new_post.edit_date = timezone.now()
new_post.save()
return redirect('../')
return render(request, 'forum/edit_post.html', {'form': form, 'selected_post': post, 'topic': topic, 'posts': posts})
def get_context_data(self, *args, **kwargs):
context = super(PostsList, self).get_context_data(**kwargs)
context['form'] = PostForm()
# data for pagination
context['pag_url'] = reverse('forum:theme',
kwargs={'theme_id': self.theme_id})
context['theme'] = get_object_or_404(Theme, pk=self.theme_id)
return context
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 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 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 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 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 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(request, pk):
"View that handles POST request for a reply or renders the form for a reply"
error = ""
if request.method == "POST":
p = request.POST
if p["body_markdown"]:
thread = Thread.objects.get(pk=pk)
post = Post()
form = PostForm(p, instance=post)
post = form.save(commit=False)
post.thread, post.creator = thread, request.user
post.save()
return HttpResponseRedirect(reverse("forum.views.thread", args=[pk]) + "?page=last")
else:
error = "Please enter a Reply\n"
thread = Thread.objects.get(pk=pk)
post_form = PostForm()
return render_to_response(
"forum/reply.html", add_csrf(request, thread=thread, post_form=post_form, error=error, pk=pk)
)
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 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 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 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 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 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 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)
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 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_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 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 write_post(request):
if not request.user.is_authenticated:
return redirect('home')
if request.method == "POST":
title = request.POST.get("title")
content = request.POST.get("content")
author = request.user
new_post = Post(author=author,
title=title,
content=content,
created=datetime.datetime.now())
new_post.save()
return redirect('forum:post_successful')
else:
context = {"current_page": "write_post"}
context['user'] = request.user
context["form"] = PostForm()
return render(request, "write_post.html", context)
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(self, request, *args, **kwargs):
if request.method == 'POST':
#if this is a POST request in class-based views
form = self.form_class(
request.POST,
request.FILES) #create form instance and populate with data
if form.is_valid():
post = form.save(
commit=False
) #commit False means do not save post yet as we need to add post author & created_date.
post.author = request.user
post.created_date = timezone.now()
post.save()
return redirect('forum:post_list')
else:
form = PostForm()
return render(request, self.template_name, {'form': form})
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 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 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 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 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_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 respond_post(request, postid):
if not request.user.is_authenticated:
return redirect('home')
if request.method == "POST":
title = request.POST.get("title")
content = request.POST.get("content")
author = request.user
parent = Post.objects.get(id=postid)
new_post = Post(author=author,
title=title,
content=content,
created=datetime.datetime.now(),
parent=parent,
parentid=postid,
parenttitle=parent.title,
parentauthor=parent.author)
new_post.save()
return redirect('forum:post_successful')
else:
context = {}
context['user'] = request.user
context['form'] = PostForm()
context['parent'] = Post.objects.get(id=postid)
return render(request, "respond_post.html", context)
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 new_post(request, topic_id, post_id=''):
topic = get_object_or_404(Topic, id=topic_id)
if post_id != '':
post = get_object_or_404(Post, id=post_id)
else:
post = None
posts = topic.post_set.order_by('date_added')
if request.method != 'POST':
form = PostForm()
else:
form = PostForm(request.POST)
if form.is_valid():
new_post = form.save(commit=False)
new_post.topic = topic
new_post.father = post
new_post.author = request.user
new_post.save()
topic = Topic.objects.get(id=topic_id)
topic.last_update = timezone.now()
topic.last_poster = new_post.author
topic.save()
return redirect('../')
return render(request, 'forum/new_post.html', {'topic': topic, 'posts': posts, 'form': form, 'post': post})
def post_reply(request, topic_id):
if 'userid' in request.session:
topic = Topic.objects.get(pk=topic_id)
form = PostForm
status = 'student'
stud_obj = student.objects.get(pk=request.session['userid'])
username = stud_obj.uname
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = request.POST.get('title')
post.body = request.POST.get('body')
obj = student.objects.get(pk=request.session['userid'])
post.creator = obj
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return HttpResponseRedirect(
reverse('topic-detail', args=(topic.id, )))
return render(
request,
'forum/reply.html',
{
'form': form,
'topic': topic,
'username': username,
'status': status
},
)
elif 'instructorid' in request.session:
topic = Topic.objects.get(pk=topic_id)
form = PostForm
status = 'instructor'
inst_obj = instructor.objects.get(pk=request.session['instructorid'])
username = inst_obj.uname
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = Post()
post.topic = topic
post.title = request.POST.get('title')
post.body = request.POST.get('body')
obj = instructor.objects.get(
pk=request.session['instructorid'])
post.by_instructor = obj
post.user_ip = request.META['REMOTE_ADDR']
post.save()
return HttpResponseRedirect(
reverse('topic-detail', args=(topic.id, )))
return render(
request,
'forum/reply.html',
{
'form': form,
'topic': topic,
'username': username,
'status': status
},
)
else:
return HttpResponseRedirect('/joinus/login/')
def test_post_form_field_labels(self):
# Test field labels.
form = PostForm()
self.assertEqual(form.fields['title'].label, 'Title')
self.assertEqual(form.fields['text'].label, 'Text')
def get(self, request, *args, **kwargs):
form = PostForm(request.POST or None)
return render(request, 'forum/post_form.html', {
'form': form,
})
