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 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 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 thread!")
return redirect(reverse('thread', args={thread.pk}))
else:
form = PostForm(instance=post)
args = {
'form':
form,
'form_action':
reverse('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 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 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 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 data2(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
domain = form.cleaned_data.get('domain_name')
cert = form.cleaned_data.get('public_key')
pri = form.cleaned_data.get('private_key')
#if str(pub) == str(pri) :
if ssl_valid(cert, pri, domain):
form.save()
#ssl_valid(pub,pri,domain)
print cert, pri
print 'VALIDATION SUCCESS'
#return redirect('home_page')
form = PostForm1(request.POST)
return render(request, 'model_form_upload.html', {
'form': form,
'error': 'VALIDATION SUCCESS'
})
else:
print 'VALIDATION FAILED'
return render(request, 'model_form_upload.html', {
'form': form,
'error': 'VALIDATION FAILED'
})
else:
form = PostForm()
return render(request, 'model_form_upload.html', {'form': form})
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 user_posts_scroll(request, page):
posts_list = Post.objects.filter(
Q(user=request.user) | Q(elos__membros=request.user)).order_by(
'-data_de_atualizacao', '-data_de_criacao').distinct()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.instance.user = request.user
form.save()
if not len(form.instance.elos.all()):
for elo in Elo.objects.filter(membros=request.user):
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(page)
except InvalidPage:
raise Http404()
return direct_to_template(request, 'posts/user_posts_scroll.html', {
'posts': posts,
'next': reverse('posts.views.user_posts')
})
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 post_news(request):
print "************************** before form object"
form = PostForm()
print "************************** before form save"
form.save(request.user)
print "************************** before redirect"
return HttpResponseRedirect(reverse('core.views.list_news'))
def user_posts(request):
elos = Elo.objects.filter(membros=request.user)
if request.method == 'POST':
form = PostForm(request.POST)
form.fields['elos'].queryset = elos
if form.is_valid():
form.instance.user = request.user
form.save()
if not len(form.instance.elos.all()):
for elo in elos:
form.instance.elos.add(elo)
form = PostForm()
form.fields['elos'].queryset = elos
else:
form = PostForm(request.GET)
form.fields['elos'].queryset = elos
posts_list = Post.objects.filter(
Q(user=request.user) | Q(elos__membros=request.user)).order_by(
'-data_de_atualizacao', '-data_de_criacao').distinct()
paginator = Paginator(posts_list, 10)
posts = paginator.page(1)
return direct_to_template(request, 'posts/user_posts.html', {
'posts': posts,
'form': form,
})
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 new_post(request):
form = PostForm()
if request.method == 'POST' :
form = PostForm(request.POST)
if form.is_valid():
form.save(request.user)
return HttpResponseRedirect(reverse('core.views.list_posts'))
return render_to_response('new_post.html', locals(), context_instance=RequestContext(request))
def create_post():
"""Método responsável em salvar informações do blog."""
form = PostForm()
if form.validate_on_submit():
form.save()
flash('Post foi salvo no banco de dados.')
return redirect(url_for('get'))
return render_template('form_post.html', form=form, title='Criar post', action="create")
def new_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid:
form.save()
return HttpResponseRedirect('/blag/list')
else:
form = PostForm()
return render(request, 'new_post.html', {'form':form})
def nuevo_post(request):
if request.method == 'POST':
formulario = PostForm(request.POST, request.FILES)
if formulario.is_valid():
formulario.save()
return HttpResponseRedirect('/')
else:
formulario = PostForm()
return render_to_response('postform.html', {'formulario':formulario}, context_instance=RequestContext(request))
def enter_post(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
form.save()
#still needs the ability to create tags from this view
return redirect("/blog/")
else:
form = PostForm()
return render_to_response("enter_post.html", {'form':form}, context_instance=RequestContext(request))
def create(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
form.save()
else:
form = PostForm()
return render_to_response('blog/edit.html',
{'form':form},
context_instance=RequestContext(request))
def update_post(id):
post = Post.get_by_id(id)
form = PostForm()
title = 'Update - %s' % form.title.data
action = '%i/update' % int(id)
if form.validate_on_submit():
form.model = post
form.save()
flash('Post atualizado.')
return redirect(url_for('get'))
return render_template('form_post.html', form=form, title=title, action=action)
def create_post():
"""Método responsável em salvar informações do blog."""
form = PostForm()
if form.validate_on_submit():
form.save()
flash('Post foi salvo no banco de dados.')
return redirect(url_for('get'))
return render_template('form_post.html',
form=form,
title='Criar post',
action="create")
def edit(request,post_id):
post = get_object_or_404(Post,id=post_id)
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
else:
form = PostForm(instance=post)
return render_to_response('blog/edit.html',
{'form':form},
context_instance=RequestContext(request))
def create_post(request, user_id):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.user_id = user_id
form.pub_date = datetime.now()
form.save()
return redirect(reverse('show_posts', args=(user_id,)))
form = PostForm()
return render(request, 'create_post.html',
{'user_id': user_id, 'form': form.as_p()})
def edit(request, post_id):
if request.method == "POST":
post = Post.objects.get(id=post_id)
post_form = PostForm(request.POST or None, instance=post)
if post_form.is_valid():
post_form.save()
return redirect("my_posts")
post = Post.objects.get(id=post_id)
post_form = PostForm(request.POST or None, instance=post)
context = {"form": post_form, "post": post}
return render(request, "posts/edit.html", context)
def add(request):
if request.POST:
p = PostForm(request.POST)
if p.is_valid():
p.save()
return HttpResponseRedirect(reverse('testapp.views.home'))
else:
p = PostForm()
return render(request, 'addpost.html', {
'form': p,
})
def add_post(request):
context = RequestContext(request)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form.save(commit=True)
return redirect(index)
else:
print form.errors
else:
form = PostForm()
return render_to_response('blog/add_post.html', {'form': form}, context)
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 createPost (request):
if request.POST:
form = PostForm (request.POST)
if form.is_valid ():
form.save ()
return HttpResponseRedirect ('')
else:
form = PostForm ()
context = {'form': form}
return render (request, 'blog/createPost.html', context)
def editPost (request, post_id):
post = Post.objects.get (id=post_id)
form = PostForm (instance = post)
if request.POST:
form = PostForm (request.POST, instance = post)
if form.is_valid ():
form.save ()
return HttpResponseRedirect ('')
context = {'form': form}
return render (request, 'blog/editPost.html', context)
def post_new(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save() # save the Post
return redirect('index')
else:
return redirect('newpost') # back to same new page if wrong
return render_to_response('blog/post_edit.html', {'form': form}, RequestContext(request))
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 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 update_post(id):
post = Post.get_by_id(id)
form = PostForm()
title = 'Update - %s' % form.title.data
action = '%i/update' % int(id)
if form.validate_on_submit():
form.model = post
form.save()
flash('Post atualizado.')
return redirect(url_for('get'))
return render_template('form_post.html',
form=form,
title=title,
action=action)
def create(request):
if request.POST:
form = PostForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/feedback/course_review')
else
form = PostForm()
args = {}
args.update(csrf(request))
args['form'] = form
return render_to_response('create_feedback.html', args)
def post_edit(request, id):
post = get_object_or_404(Post, id=id)
if request.method == 'GET':
form = PostForm(instance=post)
else:
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return redirect('homepage')
data = {
'form': form,
'post': post,
}
return render_to_response('post_edit.html', data, context_instance=RequestContext(request))
def edit_post(request, id):
if request.POST:
post = get_object_or_404(Blog, pk=id)
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return HttpResponseRedirect('/')
else:
post = get_object_or_404(Blog, pk=id)
form = PostForm(instance=post)
context = {'form': form, 'post': post}
#return render(request, 'view_form.html', context)
return render_to_response('view_form.html',
{'form': form, 'post': post},
context_instance=RequestContext(request))
def write(request):
if request.method =='POST':
content = Content(date = timezone.now())
form = PostForm(request.POST, instance=content)
if form.is_valid():
form.save()
return HttpResponseRedirect('')
else:
form = PostForm()
content_list = Content.objects.all().order_by('id').reverse()
return render_to_response('blog/index.html',
RequestContext(request,
{ 'content_list':content_list,
'form':PostForm,
}))
def edit_post(request, post_id):
post = Post.get_by_id(int(post_id))
if not post:
raise Http404
if request.method == 'GET':
form = PostForm({
'title': post.title,
'content': post.content,
# 'tags': post.tags,
'category': post.category.key(),
'is_published': post.is_published
})
tagsString = post.getTagsString()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
modified_post = form.save(commit=False)
if modified_post.category.key() != post.category.key():
post.category.post_count -= 1
post.category.put()
modified_post.category.post_count += 1
modified_post.category.put()
post.title = modified_post.title
post.category = modified_post.category
post.content = modified_post.content
post.is_published = modified_post.is_published
post.putTags(request.POST['tagsString'])
post.put()
return HttpResponseRedirect('/post/%s/' % post.key().id())
return render_to_response('operate_post.html', {
'form': form,
'id': post.key().id,
'tagsString': tagsString
},
context_instance=RequestContext(request))
def post_edit(request, id):
instance = get_object_or_404(post, id=id)
if request.user.id == instance.author_id:
args = {}
instance = get_object_or_404(post, id=id)
args.update(csrf(request))
if request.method == "POST":
form = PostForm(request.POST, request.FILES, instance=instance)
args["err"] = form.errors
if form.is_valid():
instance = form.save(commit=False)
instance.author_id = request.user.id
instance.save()
return HttpResponseRedirect('/dashboard')
args["form"] = PostForm(instance=instance)
args["form_title"] = "Edit Article"
return render(request, 'register.html', args, RequestContext(request))
else:
context = {
"msg": "You are not allowed to perform this action",
"show": "alert-danger"
}
return render(request, 'dashboard.html', 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_create(request):
form = PostForm(request.POST or None, request.FILES or None)
if form.is_valid():
instance = form.save(commit=False)
instance.save()
context = {"form": form}
return render(request, "my_blog/post_create.html", context)
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 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_view(request, id=None):
post_sent = None
post_title = None
post_update = None
post = None
user_name = request.user.username
form = PostForm()
if id:
post = get_object_or_404(Post, id=id)
form = forms.PostForm(instance=post)
post_update = True
if request.method == 'POST':
form = forms.PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
tags = form.cleaned_data['tags']
post.author = request.user
post.save()
for tag in tags:
post.tags.add(tag)
post_title = post.title
post_sent = True
return render(
request, 'BlogApp/post_form.html', {
'form': form,
'post_sent': post_sent,
'post_title': post_title,
'post_update': post_update
})
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 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 reply_topic(request, pk, topic_pk):
topic = get_object_or_404(Topic, board__pk=pk, pk=topic_pk)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.topic = topic
post.created_by = request.user
post.save()
topic.last_updated = timezone.now() # <- here
topic.save()
topic_url = reverse('topic_posts',
kwargs={
'pk': pk,
'topic_pk': topic_pk
})
topic_post_url = '{url}?page={page}#{id}'.format(
url=topic_url, id=post.pk, page=int(topic.get_page_count()))
return redirect(topic_post_url)
else:
form = PostForm()
return render(request, 'board/reply_topic.html', {
'topic': topic,
'form': form
})
def add_post(request):
form = PostForm(request.POST or None)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.save()
return redirect(post)
return render_to_response('blog/add_post.html', {'form': form},
context_instance=RequestContext(request))
def post_new(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.save()
return redirect('blog:post_detail', pk=post.pk)
else:
form = PostForm()
return render(request, 'blog/post_edit.html', {'form': form})
def add(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.save()
return redirect('index')
else:
form = PostForm()
return render(request, 'posts/form.html', {'form': form})
def add(request):
form = PostForm(request.POST or None)
if request.POST and form.is_valid():
with reversion.create_revision():
post = form.save(commit=False)
if isinstance(request.user, AnonymousUser):
request.user = User.objects.get(username="******")
post.creator = request.user
post.updater = request.user
form.save()
reversion.set_user(request.user)
comment = request.POST['comment'] or "Initial version."
reversion.set_comment(comment)
log(request, post, comment)
return redirect('/blog/')
#return render_to_response('blog/index.html',
# context_instance=RequestContext(request))
return render_to_response('blog/add.html', {'form': form},
context_instance=RequestContext(request))
def post_edit(request, pk):
post = get_object_or_404(Post, pk=pk)
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.save()
return redirect('blog:post_detail', pk=post.pk)
else:
form = PostForm(instance=post)
return render(request, 'blog/post_edit.html', {'form': form})
def post_update(request, id=None):
instance = get_object_or_404(Post, id=id)
form = PostForm(request.POST or None,
request.FILES or None,
instance=instance)
if form.is_valid():
instance = form.save(commit=False)
instance.save()
context = {"form": form, "title": instance.title, "instance": instance}
return render(request, "my_blog/post_create.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
post.save()
return redirect('post_detail', pk=post.pk)
else:
form = PostForm()
return render(request, 'django_app/post_edit.html', {'form': form})
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
post.published_date = timezone.now()
post.save()
return redirect('post_detail', pk=post.pk)
else:
form = PostForm()
return render(request, 'blog/post_edit.html', {'form': form})
def home(request):
Names.objects.all().delete()
Character.objects.all().delete()
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.save()
return redirect('detail')
else:
form = PostForm()
return render(request, 'search/homepage.html', {'form': form})
def new_thread(request, subject_id):
subject = get_object_or_404(Subject, pk=subject_id)
poll_subject_formset = formset_factory(PollSubjectForm, extra=3)
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)
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()
if request.POST.get('is_a_poll', None) and poll_form.is_valid(
) and poll_subject_formset.is_valid():
poll = poll_form.save(False)
poll.thread = thread
poll.save()
for subject_form in poll_subject_formset:
subject = subject_form.save(False)
subject.poll = poll
subject.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)
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,
}
args.update(csrf(request))
return render(request, 'forum/thread_form.html', args)
