def test_body_required_robert(self):
pf = PostForm({ 'body' : 'yay' })
self.assertTrue(pf.is_valid())
pf = PostForm({ 'body' : '' })
self.assertFalse(pf.is_valid())
pf = PostForm({ 'body' : ' \t \t \n\n\n' })
self.assertFalse(pf.is_valid())
def test_reply_no_title(self):
author = User.objects.get(username = '******')
form = PostForm({'title' : 'This is a title', 'content' : 'This is a content'}, author = author)
self.assertTrue(form.is_valid())
post = form.save()
author_reply = User.objects.get(username = '******')
form_reply = PostForm({'content' : 'This is a reply content'}, author = author_reply, parent = post)
self.assertTrue(form_reply.is_valid())
def test_reply_no_parent(self):
author = User.objects.get(username = '******')
form = PostForm({'title' : 'This is a title 1234567890', 'content' : 'This is a content 123456789012345678901234567890'}, author = author)
self.assertTrue(form.is_valid())
post = form.save()
author_reply = User.objects.get(username = '******')
form_reply = PostForm({'content' : 'This is a content 123456789012345678901234567890'}, author = author_reply)
self.assertFalse(form_reply.is_valid())
def test_edit_post(self):
author = User.objects.get(username = '******')
form = PostForm({'title' : 'This is title 1234567890', 'content' : 'This is content 123456789012345678901234567890',
} , author = author)
self.assertTrue(form.is_valid())
post = form.save()
form = PostForm({'title' : 'This is another title 1234567890', 'content' : 'This is another content 123456789012345678901234567890'},
instance = post, author = author)
self.assertTrue(form.is_valid())
def test_edit_post_different_user_normal(self):
author = User.objects.get(username = '******')
form = PostForm({'title' : 'This is title', 'content' : 'This is content',
} , author = author)
self.assertTrue(form.is_valid())
post = form.save()
author_normal = User.objects.get(username = '******')
form = PostForm({'title' : 'This is another title', 'content' : 'This is another content'},
instance = post, author = author_normal)
self.assertFalse(form.is_valid())
def test_duplicated_content_regardless_author(self):
author = User.objects.get(username = '******')
form1 = PostForm({'title' : 'This is title 1234567890', 'content' : 'This is content 123456789012345678901234567890',
} , author = author)
form2 = PostForm({'title' : 'This is title 1234567890', 'content' : 'This is content 123456789012345678901234567890',
} , author = author)
self.assertTrue(form1.is_valid())
form1.save()
self.assertFalse(form2.is_valid())
def test_edit_reply_different_user_normal(self):
author = User.objects.get(username = '******')
form = PostForm({'title' : 'This is a title 1234567890', 'content' : 'This is a content 123456789012345678901234567890'}, author = author)
self.assertTrue(form.is_valid())
post = form.save()
author_reply = User.objects.get(username = '******')
form_reply = PostForm({'content' : 'This is a reply content 123456789012345678901234567890'}, author = author_reply, parent = post)
self.assertTrue(form_reply.is_valid())
reply = form_reply.save()
author_reply_normal = User.objects.get(username = '******')
form_reply2 = PostForm({'content' : 'This is another reply content 123456789012345678901234567890'}, instance = reply, author = author_reply_normal)
self.assertFalse(form_reply2.is_valid())
def test_reply_duplicated_content_regardless_author(self):
author = User.objects.get(username = '******')
form = PostForm({'title' : 'This is a title 1234567890', 'content' : 'This is a content 123456789012345678901234567890'}, author = author)
self.assertTrue(form.is_valid())
post = form.save()
author_reply = User.objects.get(username = '******')
form_reply = PostForm({'content' : 'This is a reply content 123456789012345678901234567890'}, author = author_reply, parent = post)
self.assertTrue(form_reply.is_valid())
form_reply.save()
author_reply2 = User.objects.get(username = '******')
form_reply2 = PostForm({'content' : 'This is a reply content 123456789012345678901234567890'}, author = author_reply2, parent = post)
self.assertFalse(form_reply2.is_valid())
def submit(request):
"""Submit new post view"""
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
#Process form data
#u = User.objects.get(username = "******")
#u = request.user
p = Post(subject = form.cleaned_data['subject'], text = form.cleaned_data['text'], user = request.user)
p.slug = slugify(form.cleaned_data['subject'])
raise AttributeError
p.save()
urlredirect = '/posts/%s' % p.slug
#return render_to_response('posts/view.html', {'post': p, 'user': request.user})
return redirect_to(request, urlredirect)
else:
form = PostForm()
return render_to_response('posts/submit.html', {'form': form, 'user': request.user})
#@login_required
#def my_post_comment(request):
# """Wrapper for django's comments/post"""
# if request.user.is_authenticated():
# return post_comment(request)
# return HttpResponseRedirect('/login/?next=%s' % request.path)
# return (HttpResponse)
def add_post(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
s = form.cleaned_data['title']
i = s.split(" ")
slug = "-".join(i)
post = Post(
title = form.cleaned_data['title'],
body = form.cleaned_data['body'],
slug = slug,
user = request.user,
)
post.save()
return redirect("/%s" % post.slug)
else:
# form validation did not go so well.
pass
else:
# assuming GET
form = PostForm()
return render_to_response(
'posts/addpost.html',
{'form': form},
context_instance=RequestContext(request))
def post(request, board_type, post_id=None):
var = {
'page': board_type,
'board_type': BoardType.objects.get(type=board_type)
}
post = None
#if post_id is not None:
# post = Post.objects.get(pk=post_id)
if request.method == 'POST':
form = PostForm(data=request.POST, files=request.FILES)
if form.is_valid():
form.save()
return redirect(board_type)
else:
var['form'] = form
elif post is not None and request.user == post.author:
var['form'] = PostForm(instance=post)
else:
var['form'] = PostForm()
return render(request, 'post.html', var)
def elo_posts_scroll(request, slug, page):
try:
elo = Elo.objects.filter(Q(tipo='A') | Q(membros=request.user.id)).filter(slug=slug)[0]
except:
raise Http404()
posts_list = Post.objects.filter(elos=elo).order_by('-data_de_atualizacao', '-data_de_criacao')
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.instance.user = request.user
form.save()
form.instance.elos.add(elo)
else:
raise Http404()
else:
post_id = request.GET.get('post_id')
if post_id:
posts_list = posts_list.filter(id=post_id)
paginator = Paginator(posts_list, 10)
try:
posts = paginator.page(int(page))
except InvalidPage:
raise Http404()
return direct_to_template(request, 'posts/user_posts_scroll.html', {'posts': posts,})
def sign(request):
form = PostForm(request.POST)
if form.is_valid():
post = Post(author=form.cleaned_data["author"], message=form.cleaned_data["message"])
post.put()
return HttpResponseRedirect("/")
def add_thread(request, template="forum/add_thread.html"):
"Create new thread and first post"
def get_slug(text, numb=0):
"Create unique slug"
text = text[:110]
if numb:
text = text.rsplit("_", 1)[0] + "_%d" % numb
s = slugify(text)
if Thread.objects.filter(slug=s).count():
return get_slug(text, numb + 1)
return s
u = request.user
tf = ThreadForm()
pf = PostForm()
if request.POST:
t = Thread(author=u, latest_post_author=u,
slug=get_slug(request.POST['title']))
tf = ThreadForm(request.POST, instance=t)
if tf.is_valid():
tfins = tf.save()
p = Post(thread=tfins, author=u)
pf = PostForm(request.POST, instance=p)
if pf.is_valid():
pfins = pf.save()
return HttpResponseRedirect(tfins.get_absolute_url())
else:
tfins.delete()
return render_to_response(template, {
"t_form": tf,
"p_form": pf,
}, context_instance=RequestContext(request))
def create_post(request):
# Get the context from the request.
context = RequestContext(request)
# A HTTP POST?
if request.method == 'POST':
form = PostForm(request.POST)
# Have we been provided with a valid form?
if form.is_valid():
# Save the new category to the database.
form.save(commit=True)
# Now call the index() view.
# The user will be shown the homepage.
return HttpResponseRedirect('/')
else:
# The supplied form contained errors - just print them to the terminal.
print form.errors
else:
# If the request was not a POST, display the form to enter details.
form = PostForm()
# Bad form (or form details), no form supplied...
# Render the form with error messages (if any).
return render_to_response('posts/create_post.html', {'form': form}, context)
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 thread!")
return redirect(reverse('thread', args={thread.pk}))
else:
form = PostForm()
args = {
'form': form,
'form_action': reverse('new_post', args={thread.id}),
'button_text': 'Update Post'
}
args.update(csrf(request))
return render(request, 'forum/post_form.html', args)
def post_new(request, category_id=None):
category = None
if request.method == 'POST':
post_form = PostForm(request.POST)
if post_form.is_valid():
post = post_form.save(commit=False)
post.user = request.user
post.is_comment = False
post.forum = Forum.objects.all()[0]
post.post_ip = request.META.get('REMOTE_ADDR', "0.0.0.0")
post.save()
post_form.save_m2m()
return HttpResponseRedirect(reverse("post", args=[post.pk]))
else:
if category_id is not None and category_id != '':
category = Category.objects.get(pk=category_id)
post_form = PostForm(initial={'categories': [category]})
else:
post_form = PostForm()
return render_to_response("forum/form.html", {
'form': post_form,
'category': category,
'categories': Category.objects.all()
}, context_instance=RequestContext(request))
def add_post(request):
if request.method == "POST":
post_form = PostForm(request.POST, request.FILES)
if post_form.is_valid():
title = post_form.cleaned_data['title']
keywords = post_form.cleaned_data['keywords']
description = post_form.cleaned_data['description']
image = post_form.cleaned_data['image']
text = post_form.cleaned_data['text']
slug = title
new_post = Post(title=title,
userid=request.user,
slug=slug,
keywords=keywords,
image=image,
text=text,
description=description,
date=datetime.now())
new_post.save()
post_form = PostForm()
return render(request,
'blog/add_post.html',
{'post_form': post_form})
else:
post_form = PostForm()
ctx = {'post_form': post_form}
return render(request,
'blog/add_post.html',
ctx, )
def post(request):
if request.method == 'POST':
post_form = PostForm(request.POST)
username = str(request.user)
if post_form.is_valid():
title = post_form.cleaned_data.get('title','')
body = post_form.cleaned_data.get('body','')
new_post = {
'title':title,
'body':body,
'author':username,
'time':time.time(),
'show':True,
'type':'post',
'comments':[],
}
post_id = make_post(new_post)
user_post(username,post_id)
else:
print "form was not valid"
return HttpResponseRedirect(reverse('forum:home'))
def new_thread(request, subject_id):
subject = get_object_or_404(Subject, pk=subject_id)
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(False)
thread.subject = subject
thread.user = request.user
thread.save()
post = post_form.save(False)
post.user = request.user
post.thread = thread
post.save()
messages.success(request, "You have create a new thread!")
return redirect(reverse('thread', args={thread.pk}))
else:
thread_form = ThreadForm()
post_form = PostForm(request.POST)
args = {
'thread_form': thread_form,
'post_form': post_form,
'subject': subject,
}
args.update(csrf(request))
return render(request, 'forum/thread_form.html', args)
def newpost(request):
args = {}
args.update(csrf(request))
#info gathering--------------------------------------------------------
m = get_object_or_404(Member, user=request.user.profile)
#making some fun stuff-----------------------------------------------
if request.POST:
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form = form.save(commit=False)
form.user = m
form.save()
return HttpResponseRedirect(reverse('allposts'))
else:
form = PostForm()
#packing bags and fly--------------------------------------------------
args.update({'form': form})
template = 'newpost.html'
context = RequestContext(request)
return render_to_response(template, args, context_instance=context)
def editpost(request, post_id):
args = {}
args.update(csrf(request))
#info gathering--------------------------------------------------------
m = get_object_or_404(Member, user=request.user.profile)
p = Post.objects.get(id=post_id)
#making some fun stuff-----------------------------------------------
if m == p.user:
if request.method == 'POST':
form = PostForm(request.POST, request.FILES, instance=p)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('post', kwargs={"post_id": post_id}))
else:
form = PostForm(instance=p)
else:
raise Http404
#packing bags and fly--------------------------------------------------
args.update({'form': form})
template = 'editpost.html'
context = RequestContext(request)
return render_to_response(template, args, context_instance=context)
def post_edit(request, track_id=None, point_id=None):
if track_id is not None:
track = get_object_or_404(Track, id=track_id)
url_name = 'manager_tracks'
elif point_id is not None:
track = get_object_or_404(Point, id=point_id)
url_name = 'manager_points'
else:
return HttpResponseNotFound()
if track.post is None:
post = Post(title=track.name,
text='')
post.save()
track.post = post
track.save()
else:
post = track.post
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
if request.POST.get('submit', 'to_current_page') == 'to_section':
return HttpResponseRedirect(reverse(url_name))
else:
form = PostForm(instance=post)
title = u'Редактирование "%s"' % post.title
return render_to_response('post_edit.html',
{'form': form,
'title': title,
'back_url': reverse(url_name)
},
RequestContext(request))
def new_message(request, mlist_fqdn):
""" Sends a new thread-starting message to the list.
TODO: unit tests
"""
store = get_store(request)
mlist = store.get_list(mlist_fqdn)
failure = None
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
today = datetime.date.today()
redirect_url = reverse(
'archives_with_month', kwargs={
"mlist_fqdn": mlist_fqdn,
'year': today.year,
'month': today.month})
redirect_url += "?msg=sent-ok"
try:
post_to_list(request, mlist, form.cleaned_data['subject'],
form.cleaned_data["message"],
attachments=request.FILES.getlist("attachment"))
except PostingFailed, e:
failure = str(e)
else:
return redirect(redirect_url)
def add_post(request, thread_slug, post_id=None,
template="forum/add_post.html"):
"Add new post"
t = get_object_or_404(Thread, slug=thread_slug)
u = request.user
if t.closed:
return HttpResponseRedirect(t.get_absolute_url())
if t.latest_post.author == u:
return edit_post(request, thread_slug, t.latest_post.id)
#return HttpResponseRedirect(t.get_absolute_url())
if request.POST:
p = Post(thread=t, author=u)
f = PostForm(request.POST, instance=p)
if f.is_valid():
f.save()
return HttpResponseRedirect(t.get_absolute_url())
else:
data = {}
if post_id:
q_post = t.post_set.get(id=post_id)
q_info = u">**%s powiedział:**\n>" % q_post.author.username
q_info = [q_info, ]
q_msg = [l for l in q_post.text.split("\n")]
data['text'] = "\n> ".join(q_info + q_msg) + "\n\n"
f = PostForm(data)
return render_to_response(template, {
"topic": t,
"form": f,
}, context_instance=RequestContext(request))
def sub_post(request, id_num): #for nested posts
pform = PostForm(request.POST or None)
parent = get_object_or_404(Post, pk=id_num)
if (request.method == 'POST'
and request.user.is_authenticated()):
if pform.is_valid():
title = pform.cleaned_data["title"]
check = Post.objects.filter(title=title).order_by("-identifier")
check_int = 0
if len(check) > 0:
check_int = check[0].identifier + 1
post = Post(title=title,
body=pform.cleaned_data["body"],
parent=parent,
user=request.user,
identifier=check_int)
post.save()
messages.success(request, "Post submitted correctly")
else:
### meaningful errors here would be helpful
### messages.error(request, pform.errors)
return render_to_response("post_form.html",
{'pform' : pform, 'post':parent},
RequestContext(request))
return HttpResponseRedirect("/posts/"+id_num)
def new_message(request, mlist_fqdn):
""" Sends a new thread-starting message to the list.
TODO: unit tests
"""
store = get_store(request)
mlist = store.get_list(mlist_fqdn)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
_send_email(request, mlist, form.cleaned_data['subject'],
form.cleaned_data["message"])
today = datetime.date.today()
redirect_url = reverse(
'archives_with_month', kwargs={
"mlist_fqdn": mlist_fqdn,
'year': today.year,
'month': today.month})
redirect_url += "?msg=sent-ok"
return redirect(redirect_url)
else:
form = PostForm()
context = {
"mlist": mlist,
"post_form": form,
'months_list': get_months(store, mlist.name),
}
return render(request, "message_new.html", context)
def post_new(request):
"""新建文章"""
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
# 开始处理标签
print post.author
ptags = request.POST['tags'].strip()
all_tags = []
if ptags:
tags = ptags.split(',')
for tag in tags:
try:
t = Tag.objects.get(name=tag)
except Tag.DoesNotExist:
t = Tag(name=tag)
t.save()
all_tags.append(t)
post.save()
for tg in all_tags:
post.tags.add(tg)
return redirect('blog.views.post_detail', pk=post.pk)
else:
form = PostForm()
return render_to_response('post_edit.html', {'form': form, 'is_new': True},context_instance=RequestContext(request))
def addpost(request):
if request.POST:
#files = upload_receive(request)
form = PostForm(request.POST, request.FILES)
if form.is_valid():
f2 = form.save(commit=False)
f2.pub_date = datetime.now()
f2.save()
tags = f2.tags
tags = tags.split(',')
tagobjs = Tag.objects.all()
taglist=[]
for i in tagobjs: #Adding new tags
taglist.append(i.name)
for i in tags:
if i not in taglist:
obj = Tag(name=i)
obj.save()
print 'saved'
print obj
print obj.name
taglist.append(i)
return HttpResponseRedirect('/blog/viewposts/')
else:
args = {}
args.update(csrf(request))
args['form']=form
args['error']='Some error in form'
return render_to_response('addpost.html',args)
else:
args = {}
args.update(csrf(request))
args['form'] = PostForm()
return render_to_response('addpost.html',args)
def post(self, request, grpid):
'''
make a post for given group and render
'''
try:
post_author = request.user.membership_set.get(group__pk=grpid)
except:
return HttpResponseForbidden()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
# author = from the current user's set of memberships, the one that
# has a group with matching group id (pk)
post.author = post_author
post.save()
# is anybody listening?
# if so, send new post to everyone and reset
grpid = int(grpid)
# Send notifications.
uid = request.user.id
self._send_notifications(
uid, grpid, PostNotification, post)
if grpid in self.group_event:
self.group_event[grpid].set(post)
# self.group_event = None
del self.group_event[grpid]
return render(request, 'group_post.html', {'post': post})
return HttpResponseBadRequest()
def new_thread(request, subject_id):
"""
Allows logged in users to create a new thread and post at the same time.
Also, gives the option of creating a poll when creating a new thread.
"""
subject = get_object_or_404(Subject, pk=subject_id)
poll_subject_formset = formset_factory(
PollSubjectForm, extra=3) # makes a set of 3 forms in this case.
if request.method == "POST":
thread_form = ThreadForm(request.POST)
post_form = PostForm(request.POST)
poll_form = PollForm(request.POST)
poll_subject_formset = poll_subject_formset(request.POST)
# When calling the is_valid, the formset will validate all forms in
# one go, so you can effectively treat them like they are one form.
if thread_form.is_valid() and post_form.is_valid(
) and poll_form.is_valid() and poll_subject_formset.is_valid():
thread = thread_form.save(
False) # get memory only version of the model
thread.subject = subject
thread.user = request.user
thread.save()
post = post_form.save(False)
post.user = request.user
post.thread = thread # newly created thread id
post.save()
if request.POST.get('is_a_poll', None):
poll = poll_form.save(False)
poll.thread = thread
poll.save()
# To pull out the values from each form, loop through each one.
# It is the same when rendering.
for subject_form in poll_subject_formset:
subject = subject_form.save(False)
subject.poll = poll
subject.save()
messages.success(request, "You have created a new thread!")
return redirect(reverse('thread', args={thread.pk}))
else:
thread_form = ThreadForm()
post_form = PostForm(request.POST)
poll_form = PollForm()
poll_subject_formset = poll_subject_formset()
args = {
'thread_form': thread_form,
'post_form': post_form,
'subject': subject,
'poll_form': poll_form,
'poll_subject_formset':
poll_subject_formset, # loop through the formset of 3 forms when rendering.
}
args.update(csrf(request))
return render(request, 'forum/thread_form.html', args)
def blacklist(request, messages=None):
"""
generates the blacklist: either in plain html or in website
:param request: request
:return:
"""
content = None
if not messages:
messages = {
'errors': [],
'successes': [],
'warnings': [],
}
valid_formats = ['f2b', 'firewall', 'pan']
if request.GET:
outputFormat = request.GET.get('format')
if outputFormat:
if outputFormat == 'firewall' or outputFormat == 'pan':
blacklist = generate_blacklist('firewall')
return render(request, 'blacklist_firewall.html', {
'format': outputFormat,
'blacklist': blacklist
})
elif outputFormat == 'f2b':
blacklist = generate_blacklist('firewall')
return render(request, 'blacklist_firewall.html', {
'format': outputFormat,
'blacklist': blacklist
})
else:
blacklist = "Invalid format parameter format=%s. Please use the following %s" % (
outputFormat, valid_formats)
messages['errors'].append(blacklist)
if request.method == 'POST':
try:
form = PostForm(request.POST)
form1 = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
ban_option = True
time = datetime.utcnow().replace(tzinfo=pytz.utc)
ip = request.POST.get('ip')
ban_duration = request.POST.get('blacklist_duration')
reason = request.POST.get('reason')
tag = request.POST.get('tag')
ban_offender(ip,
'ban_User',
reason,
time,
ban_option,
ban_duration,
forceBan=True)
print ip
print ban_duration
print reason
print tag
return HttpResponseRedirect('/blacklist')
if form1.is_valid() and request.FILES:
ban_option = True
user = '******'
reason = 'superReason'
uploadFile = request.FILES['file']
# banOffendersAsync.delay(uploadFile, user, reason, ban_option)
ban_offenders(uploadFile, user, reason, ban_option)
return HttpResponseRedirect('/blacklist')
else:
return HttpResponseRedirect('/blacklist')
except OverflowError:
return HttpResponseRedirect('/blacklist')
else:
form = PostForm(request.POST)
form1 = UploadFileForm(request.POST, request.FILES)
blacklist = generate_blacklist()
offenders = list(
Offenders.objects.filter(blacklisted=True).values(
'ip', 'strikes', 'total_strikes', 'last_offense_date',
'last_offense_target', 'blacklisted', 'subnet_mask',
'last_blacklisted_date', 'last_blacklist_remove_date',
'blacklist_duration', 'blacklist_removal_date', 'tag'))
blackListers = Offenders.objects.filter(blacklisted=True)
entries = []
for offender in blackListers:
entry = {
'min': {
'ip': offender.ip,
'subnet': offender.subnet_mask,
'blacklisted': offender.blacklisted,
'strikes': offender.strikes,
'total_strikes': offender.total_strikes,
'last_offense_date': offender.last_offense_date,
},
'verbose': {
'last_offense_target': offender.last_offense_target,
'last_blacklisted_date': offender.last_blacklisted_date,
'last_blacklist_remove_date':
offender.last_blacklist_remove_date,
'blacklist_removal_date': offender.blacklist_removal_date,
'blacklist_duration': offender.blacklist_duration,
'tag': offender.tag,
}
}
entries.append(entry)
if entries and entries[0]:
header = [
'IP',
'Subnet',
'Blacklisted',
'Strikes',
'Total Strikes',
'Last Offense',
]
else:
header = None
return render(
request, 'responsive.html', {
'blacklistedIP': entries,
'header': header,
'errors': messages['errors']
})
def thread_detail(request, category_slug, slug, pk=None):
if pk is not None:
edit_post = Post.objects.get(pk=pk)
if edit_post.author.user != request.user:
raise PermissionDenied
else:
edit_post = None
try:
thread = Thread.objects.get(slug=slug)
post_list = Post.objects.filter(thread=thread.pk)
except Thread.DoesNotExist:
raise Http404("Thread does not exist!")
if request.method == 'POST':
if 'edit-post' in request.POST:
edit_post_form = PostForm(request.POST, instance=edit_post)
if edit_post_form.is_valid():
edit_post_form.save()
return redirect(thread.get_absolute_url())
else:
return render(
request, 'thread.html', {
'thread': thread,
'post_list': post_list,
'edit_post_form': edit_post_form,
'category_slug': category_slug,
'slug': slug,
'pk': edit_post.pk,
'edit_post': edit_post,
})
elif 'new-post' in request.POST:
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = UserProfile.objects.get(user=request.user)
post.thread = thread
post.save()
return redirect(thread.get_absolute_url())
else:
return render(
request, 'thread.html', {
'thread': thread,
'post_list': post_list,
'form': form,
'slug': slug,
'category_slug': category_slug,
'edit_post': edit_post,
})
data = {
'thread': thread,
'post_list': post_list,
'form': PostForm(),
'slug': slug,
'category_slug': category_slug,
}
if edit_post is not None:
edit_post_form = PostForm(instance=edit_post)
data['edit_post_form'] = edit_post_form
data['pk'] = edit_post.pk
data['edit_post'] = edit_post
return render(request, 'thread.html', data)
else:
return render(request, 'thread.html', data)
def answer(request):
'''
Adds an answer from a user to a topic
'''
try:
topic_pk = request.GET['sujet']
except KeyError:
raise Http404
g_topic = get_object_or_404(Topic, pk=topic_pk)
if not g_topic.forum.can_read(request.user):
raise Http404
posts = Post.objects.filter(topic=g_topic).order_by('-pubdate')[:3]
last_post_pk = g_topic.last_message.pk
# Making sure posting is allowed
if g_topic.is_locked:
raise Http404
# Check that the user isn't spamming
if g_topic.antispam(request.user):
raise Http404
# If we just sent data
if request.method == 'POST':
data = request.POST
newpost = last_post_pk != int(data['last_post'])
# Using the « preview button », the « more » button or new post
if 'preview' in data or 'more' in data or newpost:
return render_template(
'forum/answer.html', {
'text': data['text'],
'topic': g_topic,
'posts': posts,
'last_post_pk': last_post_pk,
'newpost': newpost
})
# Saving the message
else:
form = PostForm(request.POST)
if form.is_valid() and data['text'].strip() != '':
data = form.data
post = Post()
post.topic = g_topic
post.author = request.user
post.text = data['text']
post.text_html = emarkdown(data['text'])
post.pubdate = datetime.now()
post.position = g_topic.get_post_count() + 1
post.ip_address = get_client_ip(request)
post.save()
g_topic.last_message = post
g_topic.save()
# Follow topic on answering
if not g_topic.is_followed():
follow(g_topic)
return redirect(post.get_absolute_url())
else:
raise Http404
else:
text = ''
# Using the quote button
if 'cite' in request.GET:
post_cite_pk = request.GET['cite']
post_cite = Post.objects.get(pk=post_cite_pk)
for line in post_cite.text.splitlines():
text = text + '> ' + line + '\n'
text = u'**{0} a écrit :**\n{1}\n'.format(
post_cite.author.username, text)
return render_template(
'forum/answer.html', {
'topic': g_topic,
'text': text,
'posts': posts,
'last_post_pk': last_post_pk
})
