def blog_entry_add_view(request):
"""
lets superusers add a blog entry
:param request:
:return:
"""
options = blogAttributes()
entryForm = EntryForm()
options['form'] = entryForm
options['tags'] = Tag.objects.all()
if request.POST and request.method == 'POST':
entryForm = EntryForm(request.POST)
if entryForm.is_unique(request):
entry = entryForm.customSave(request.user)
# loop through the tags
if len(entry.tags) > 0:
tags = entry.tags.split(',')
for tag in tags:
# if the tag doesn't exist
if not Tag.objects.filter(name=tag).exists():
# save the tag
t = Tag()
t.name = tag
t.save()
messages.add_message(request, messages.SUCCESS, 'The Entry has been saved')
return redirect(blog_view)
else:
messages.add_message(request, messages.ERROR, 'An Entry with this Title already exists')
return render_to_response('entryForm.html', options, context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
if "cancel" in request.POST:
return redirect("blog:admin_index")
context = self.get_context_data(**kwargs)
entry = context.get("entry")
new_entry = False
if not entry:
new_entry = True
entry = Entry(blog=self.blog)
form = EntryForm(request.POST, instance=entry)
if form.is_valid():
entry = form.save()
if request.is_ajax():
return JsonResponse(dict(status="success",
message=unicode(form.success_message)))
else:
messages.success(self.request, form.success_message)
if new_entry:
return redirect("blog:admin_edit_entry", entry_id=entry.id)
context["form"] = EntryForm(instance=entry)
return self.render_to_response(context)
else:
if request.is_ajax():
errors = {}
for field_name, errors_list in form.errors.items():
errors[field_name] = errors_list[0]
return JsonResponse(dict(status="error", errors=errors,
message=unicode(form.error_message)))
else:
messages.error(self.request, form.error_message)
context["form"] = EntryForm(request.POST)
return self.render_to_response(context)
def add_post(id=None):
if id:
post = Entry.query.filter_by(id=id).first()
form = EntryForm(
data={
'title': post.title,
'body': post.body,
'is_published': post.is_published
})
post.title = form.title.data
post.body = form.body.data
post.is_published = form.is_published.data
if form.is_published.data:
flash(f'Post "{form.title.data.upper()}" updated!')
else:
flash('Required box not checked. Post not added.')
else:
form = EntryForm()
new_post = Entry(title=form.title.data,
body=form.body.data,
is_published=form.is_published.data)
db.session.add(new_post)
if form.is_published.data:
flash(f'New post "{form.title.data.upper()}" added!')
else:
flash('Required box not checked. Post not added.')
db.session.commit()
def blog_entry_edit_view(request, eID):
"""
lets superusers edit a blog entry
:param request:
:return:
"""
options = blogAttributes()
entry = get_object_or_404(Entry, id=eID)
options['entry'] = entry
options['form'] = EntryForm(instance=entry)
if request.POST and request.method == 'POST':
entryForm = EntryForm(request.POST, instance=get_object_or_404(Entry, id=eID))
if entryForm.is_unique(request, entry):
if entryForm.has_changed():
entry = entryForm.customSave(request.user)
# loop through the tags
if len(entry.tags) > 0:
tags = entry.tags.split(',')
for tag in tags:
# if the tag doesn't exist
if not Tag.objects.filter(name=tag).exists():
# save the tag
t = Tag()
t.name = tag
t.save()
messages.add_message(request, messages.SUCCESS, 'The Entry has been updated')
return redirect(blog_entry_view, titleSlug=entry.title_slug)
else:
messages.add_message(request, messages.INFO, 'No changes have been made')
else:
messages.add_message(request, messages.ERROR, 'An Entry with this Title already exists')
return render_to_response('entryForm.html', options, context_instance=RequestContext(request))
def edit(request, pk):
entry = get_object_or_404(Entry, pk=pk)
if request.method == "POST":
form = EntryForm(request.POST, instance=entry)
if form.is_valid():
entry = form.save()
return redirect("blog.views.detail", entry.pk)
else:
form = EntryForm(instance=entry)
return render(request, "blog/form.html", {"form": form})
def newpost(request):
if request.POST:
entryform = EntryForm(request.POST)
if entryform.is_valid():
entryform.save(request)
messages.add_message(request, messages.WARNING, 'Your post is waiting to approve by admin.')
return render_to_response('home.html', RequestContext(request))
else:
entryform = EntryForm()
return render_to_response('newpost.html', {'form' : entryform}, RequestContext(request))
def new(request):
if request.method == "POST":
form = EntryForm(request.POST)
if form.is_valid():
entry = form.save(commit=False)
entry.author = request.user
entry.save()
return redirect("blog.views.detail", entry.pk)
else:
form = EntryForm()
return render(request, "blog/form.html", {"form": form})
def BlogPage(request):
if request.method == 'POST':
form = EntryForm(request.POST, request.FILES)
if form.is_valid():
newdoc = models.Entry(image1 = request.FILES['image1'])
newdoc.save()
return HttpResponseRedirect('/blog')
else:
form = EntryForm()
entries = models.Entry.objects.all()
return render_to_response('blog.html', {'entries': entries, 'form': form}, context_instance = RequestContext(request))
def get_post(id=None):
if id:
post = Entry.query.filter_by(id=id).first()
form = EntryForm(
data={
'title': post.title,
'body': post.body,
'is_published': post.is_published
})
else:
form = EntryForm()
return form
def entry_add(request):
if request.method == 'POST':
form = EntryForm(request.POST, request.FILES)
if form.is_valid():
entry = form.save(request.user)
if entry.id > 0:
return HttpResponseRedirect(entry.get_absolute_url())
else:
form_to_template = form
else:
form_to_template = EntryForm()
return render_to_response('entry_modify.html',{'form': form_to_template, 'edit': False},
context_instance = RequestContext(request))
def delete_entry(entry_id):
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
errors = None
if request.method == 'POST':
if form.validate_on_submit():
db.session.delete(entry)
db.session.commit()
flash(f'Usunięto wpis!')
return redirect(url_for('list_drafts'))
else:
errors = form.errors
return errors
def create_entry():
## return create_edit(None)
form = EntryForm()
errors = None
if request.method == 'POST':
if form.validate_on_submit():
entry = Entry(title=form.title.data,
body=form.body.data,
is_published=form.is_published.data)
db.session.add(entry)
db.session.commit()
else:
errors = form.errors
return render_template("entry_form.html", form=form, errors=errors)
def entry(entry_id=None):
if entry_id is None:
form = EntryForm()
errors = None
if request.method == "POST":
if form.validate_on_submit():
entry = Entry(
title = form.title.data,
body = form.body.data,
is_published = form.is_published.data
)
db.session.add(entry)
db.session.commit()
flash(f'Dodano wpis {form.title.data} do bloga!')
else:
errors = form.errors
return render_template("entry_form.html", form=form, errors=errors)
else:
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
errors = None
if request.method == 'POST':
if form.validate_on_submit():
form.populate_obj(entry)
db.session.commit()
flash(f'Zmieniono wpis {form.title.data}')
else:
errors = form.errors
return render_template("entry_form.html", form=form, errors=errors)
def add(request):
if request.method == 'POST':
form = EntryForm(request.POST) # A form bound to the POST data
if form.is_valid():
form.save(request.user)
messages.success(request, 'Entry was successfully added!')
return redirect('blog:index')
else:
errors = []
for field in form:
for error in field.errors:
errors.append(field.label + " " + error)
for error in form.non_field_errors():
errors.append(field.label + " " + error)
print(errors)
else:
form = EntryForm()
context = {'form': form}
return render(request, 'blog/entry.html', context)
def create_update(entry_id=None):
errors = None
if entry_id is None:
form = EntryForm()
if request.method == 'POST':
if form.validate_on_submit():
entry = Entry(
title=form.title.data,
body=form.body.data,
is_published=form.is_published.data
)
db.session.add(entry)
db.session.commit()
flash('The post has been successfully added!')
return redirect(url_for("index"))
else:
errors = form.errors
elif entry_id != 0:
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
if request.method == 'POST':
if form.validate_on_submit():
form.populate_obj(entry)
db.session.commit()
flash('The post has been successfully changed!')
return redirect(url_for("index"))
else:
errors = form.errors
return render_template("entry_form.html", form=form, errors=errors)
def create_update(entry_id=None):
errors = None
if entry_id != None:
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
if request.method == 'POST':
if form.validate_on_submit():
form.populate_obj(entry)
db.session.commit()
else:
errors = form.errors
else:
form = EntryForm()
if request.method == 'POST':
if form.validate_on_submit():
entry = Entry(
title=form.title.data,
body=form.body.data,
is_published=form.is_published.data
)
db.session.add(entry)
db.session.commit()
else:
errors = form.errors
return form, errors
def edit_entry(entry_id):
## return create_edit(entry_id)
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
errors = None
if request.method == "POST":
if form.validate_on_submit():
form.populate_obj(entry)
db.session.commit()
flash("Twój wpis został zmieniony", "info")
return redirect("/")
else:
errors = form.errors
return render_template("entry_form.html", form=form, errors=errors)
def entry_edit(request, id):
entry = get_object_or_404(Entry, pk=id)
if entry.user != request.user:
return HttpResponseRedirect(entry.get_absolute_url())
if request.method == 'POST':
form = EntryForm(request.POST, request.FILES, instance=entry)
if form.is_valid():
entry = form.save(request.user)
return HttpResponseRedirect(entry.get_absolute_url())
else:
form_to_template = form
else:
form_to_template = EntryForm(instance=entry, initial={'tags': ','.join([tag.name for tag in entry.tags.all()])})
return render_to_response('entry_modify.html',{'form': form_to_template, 'edit': True},
context_instance = RequestContext(request))
def edit(request,entry_id):
e = get_object_or_404(Entry, id=entry_id)
if request.user.id == e.author.id:
if request.POST:
entryform = EntryForm(request.POST)
if entryform.is_valid():
entryform.save_as(request,e)
messages.add_message(request, messages.WARNING, 'Your post is waiting for approvement.')
return HttpResponseRedirect('/')
else:
entryform = EntryForm({'title' : e.title, 'content' : e.content})
return render_to_response('edit.html', {'entry_id' : entry_id, 'form' : entryform}, RequestContext(request))
else:
messages.add_message(request, messages.ERROR, 'You can not edit this post, because you are not the author of it.')
return HttpResponseRedirect('/')
def create_entry(request):
form = EntryForm()
if (request.method == 'POST'):
form = EntryForm(data=request.POST)
if (form.is_valid()):
entry = form.save(False)
entry.user = request.user
entry.save()
return redirect(reverse('blog.views.blog_post', args=[entry.id]))
return render_to_response('blog/create_entry.html', {'form': form},
context_instance=RequestContext(request))
def delete_entry(entry_id):
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
if request.method == 'POST':
db.session.delete(entry)
db.session.commit()
return redirect(url_for('index'))
def delete_entry(entry_id=None):
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
db.session.delete(entry)
db.session.commit()
flash(f'Usuniętio wpis {form.title.data}')
return redirect(url_for("list_drafts"))
def create_entry():
form = EntryForm()
errors = None
if request.method == 'POST':
edit_db_entry(form=form)
return redirect(url_for('index'))
return render_template("entry_form.html", form=form, errors=errors)
def post(request, post_id=None):
"""
post a new post
"""
post = get_object_or_404(Post, id=post_id) if post_id else None
if request.method == 'POST':
form = EntryForm(request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
try:
post.content_html = format_content(post.content_format, post.content)
post.save()
return redirect(post.get_absolute_url())
except Exception, e:
messages.error(request, e.message)
def edit(request,slug=None):
entry = None
if slug:
try:
entry = Entry.objects.get(slug=slug)
except Entry.DoesNotExist:
pass
c = RequestContext(request)
c.update(csrf(request))
if request.method == 'POST':
form = EntryForm(request.POST,request.FILES)
if form.is_valid():
# If editting
if entry:
entry.content = form.cleaned_data['content']
entry.brief = form.cleaned_data['brief']
entry.public = form.cleaned_data['public']
entry.title = form.cleaned_data['title']
entry.created = form.cleaned_data['created']
if request.FILES.__contains__('image') and request.FILES['image']:
try:
entry.image.delete()
except: pass
entry.image.save(entry.slug+os.path.splitext( request.FILES['image'].name )[1],ContentFile(request.FILES['image'].read()))
#handle_uploaded_file(request.FILES['image'],str(entry.image.file))
# If NOT editting
else:
entry = form.save(commit=False)
entry.author = request.user
if request.FILES.__contains__('image') and request.FILES['image']:
entry.image.save(entry.slug+os.path.splitext( request.FILES['image'].name )[1],ContentFile(request.FILES['image'].read()))
entry.save()
return HttpResponseRedirect(ROOT_URL)
else:
return HttpResponse(str(form.errors))
form = EntryForm(instance=entry)
return render_to_response('edit.html', dict(slug=slug,form=form), context_instance=c)
def post(self, request):
form = EntryForm(request.POST)
if form.is_valid():
entry = form.update()
url = reverse_lazy('blog:entry-detail', kwargs={
'pk': entry.id
})
return HttpResponseRedirect(url)
context = {
'error_messages': form.error_messages
}
return TemplateView(request, self.template_url, context)
def edit_entry(entry_id):
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
errors = None
if request.method == 'POST':
edit_db_entry(form=form, entry_id=entry_id)
return redirect(url_for('index'))
return render_template("entry_form.html", form=form, errors=errors)
def create_or_edit_entry(**kwargs):
# GET
entry_id = kwargs.pop('entry_id', None)
form = EntryForm()
entry = None
errors = None
if entry_id:
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
# POST
if request.method == 'POST':
if form.validate_on_submit():
if entry_id:
form.populate_obj(entry)
db.session.commit()
flash(
'Zmiany w poscie zostały zapisane. '
'Aby wyświetlić go na stronie głównej pamiętaj aby zaznaczyć "Wpis opublikowany"'
)
else:
entry = Entry(title=form.title.data,
body=form.body.data,
is_published=form.is_published.data)
db.session.add(entry)
db.session.commit()
flash(
'Nowy post został dodany. '
'Aby wyświetlić go na stronie głównej pamiętaj aby zaznaczyć "Wpis opublikowany"'
)
else:
errors = form.errors
return render_template('entry_form.html', form=form, errors=errors)
def get_entries(entry_id):
errors = None
if entry_id != 0:
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
flash_mess = f'Edytowano post {entry.title} na blogu.'
else:
form = EntryForm()
entry = Entry(
title=form.title.data,
body=form.body.data,
is_published=form.is_published.data
)
flash_mess = f'Dodano post {entry.title} na bloga.'
if request.method == 'POST':
if form.validate_on_submit():
if entry_id != 0:
form.populate_obj(entry)
else:
db.session.add(entry)
db.session.commit()
flash(flash_mess)
return redirect(url_for("index"))
else:
errors = form.errors
return render_template("entry_form.html", form=form, errors=errors)
def create_edit_entry(entry_id=0):
errors = None
if entry_id == 0:
entry_form = EntryForm()
else:
entry = Entry.query.filter_by(id=entry_id).first_or_404()
entry_form = EntryForm(obj=entry)
if request.method == "POST":
if request.form["btn"] == "Save":
if entry_form.validate_on_submit():
if entry_id == 0:
entry = Entry(title=entry_form.title.data,
body=entry_form.body.data,
is_published=entry_form.is_published.data)
db.session.add(entry)
else:
entry_form.populate_obj(entry)
else:
errors = entry_form.errors
flash('Nie wpowadzono zmian', 'danger')
if request.form["btn"] == "Cancel":
return redirect(url_for("index"))
db.session.commit()
flash('Zmiany dodane pomyślnie', 'success')
return redirect(url_for("index"))
return render_template("entry_form.html",
entry_form=entry_form,
errors=errors)
def create_entry():
form = EntryForm()
entry_id = None
entry = Entry(
title=form.title.data,
body=form.body.data,
is_published=form.is_published.data
)
return create_or_edit_entry(entry_id, entry, form)
def create_entry():
form = EntryForm()
errors = None
if request.method == 'POST':
errors = new_or_edit(form)
return redirect(url_for('index', errors=errors)) #error message
return render_template("entry_form.html", form=form, errors=errors)
def add_entry(request):
# Process the submitted form if POST, displaying errors if fields required
if request.method == 'POST':
form = EntryForm(request.POST)
if form.is_valid():
entry = form.save(commit=False)
entry.author = request.user
entry.save()
return HttpResponseRedirect('/')
# Display blank entry form normally
else:
form = EntryForm()
context = {
'form': form
}
return render(request, 'blog/add.html', context)
def add_entry(request):
host = 'http://%s' % request.get_host()
if request.method == 'POST':
form =EntryForm(request.POST)
if form.is_valid():
entry = form.save(commit=False)
entry.subscription = None
entry.owner = request.user
entry.author = request.user.username
entry.subscribers_usernames = [request.user.username]
# let the author_url blank so it won't be hardcoded in the store and
# in the template, if author_link is empty, generate a link to his
# entries
entry.author_url = ''
entry.save()
# invalidate cache
clear_entries_cache(request.user.username)
# inform the hub
post_publish.send(sender=Entry, username=entry.author, host=host)
if request.is_ajax():
e = dict(
author=request.user.username,
author_url = host+'/'+request.user.username,
body = entry.body,
link = entry.link,
linktext = entry.link,
key = str(entry.key()),
permalink = '/show/'+str(entry.key()),
editlink = '/edit/'+str(entry.key()),
deletelink = '/delete/'+str(entry.key())
)
return json_response(e)
else:
return HttpResponseRedirect(reverse('user-entries',
kwargs={'username': request.user.username}))
else:
form =EntryForm()
return render_to_response('entry_form.html', {
'form': form
})
def generate_entry(entry_id):
fake = Faker()
form = EntryForm()
form.title.data = fake.sentence()
form.body.data = '\n'.join(fake.paragraphs(15))
try:
int(entry_id)
entry = Entry.query.filter_by(id=entry_id).first_or_404()
if form.validate_on_submit():
entry.title = form.title.data
entry.body = form.body.data
except ValueError:
if form.validate_on_submit():
entry = Entry(
title=form.title.data,
body=form.body.data,
is_published=True
)
db.session.add(entry)
db.session.commit()
return redirect(url_for('homepage'))
def test_valid_data(self):
entry_form = EntryForm({
'title': self.entry.title,
'body': 'entry body',
'author': self.user.id
})
self.assertTrue(entry_form.is_valid())
comment_form = CommentForm({
'name': 'Test form user',
'email': '*****@*****.**',
'body': 'body content',
'entry': self.entry.id
}, instance=self.comment)
self.assertTrue(comment_form.is_valid())
comment = comment_form.save()
self.assertEqual(comment.name, 'Test form user')
self.assertEqual(comment.email, '*****@*****.**')
self.assertEqual(comment.body, 'body content')
self.assertEqual(comment.entry.id, self.entry.id)
def newpost(request):
if request.POST:
entryform = EntryForm(request.POST)
if entryform.is_valid():
entryform.save(request)
messages.add_message(request, messages.WARNING,
'Your post is waiting to approve by admin.')
return render_to_response('home.html', RequestContext(request))
else:
entryform = EntryForm()
return render_to_response('newpost.html', {'form': entryform},
RequestContext(request))
def edit_entry(request, entry_id):
entry = get_object_or_404(Entry, pk=entry_id)
if request.method == 'POST':
form = EntryForm(request.POST, instance=entry)
if form.is_valid():
# Change the modified to now before saving
entry = form.save(commit=False)
entry.modified = datetime.datetime.now()
entry.save()
return HttpResponseRedirect('/')
# The instance fills the form with values from requested entry
else:
form = EntryForm(instance=entry)
context = {
'form': form,
'entry': entry,
}
return render(request, 'blog/edit.html', context)
def write(request):
me = Member.objects.get(user=request.user)
dbmessage = ""
if request.method == "POST":
form = EntryForm(request.POST)
if form.is_valid():
post_text = form.cleaned_data["text"]
entry = form.save(commit=False)
entry.member = me
entry.save()
message = "Journal entry saved."
return render_to_response(
"public_site/home.html",
{"message": message, "dbmessage": dbmessage},
context_instance=RequestContext(request),
)
else:
form = EntryForm()
return render_to_response("blog/write.html", {"form": form}, context_instance=RequestContext(request))
def search():
errors = None
form = EntryForm()
search_query = request.args.get("q", "")
all_posts = Entry.query.filter_by(is_published=True).order_by(
Entry.pub_date.desc())
if search_query:
posts = Entry.query.filter(
or_(Entry.title.like('%' + search_query + '%'),
Entry.body.like('%' + search_query + '%')))
return render_template("search.html",
posts=posts,
search_query=search_query)
else:
errors = form.errors
return render_template("homepage.html", form=form, errors=errors)
def edit(request, entry_id):
entry = get_object_or_404(Entry, id=entry_id)
if request.method == 'POST':
form = EntryForm(request.POST, instance=entry)
if form.is_valid():
form.save()
messages.success(request, 'Entry was successfully edited!')
return redirect('index')
else:
form = EntryForm(instance=entry)
context = {'form': form}
return render(request, 'blog/entry.html', context)
def edit_entry(request, entry_id):
"""编辑条目"""
entry = Entry.objects.get(id=entry_id)
topic = entry.topic
if topic.author != request.user: raise Http404
if request.method != 'POST':
# 未提交数据：创建一个新表单
form = EntryForm(instance=entry)
else:
# POST提交的数据，对数据进行处理
form = EntryForm(instance=entry, data=request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('blog:topic', args=[topic.id]))
context = {'entry': entry, 'topic': topic, 'form': form}
return render(request, 'blog/edit_entry.html', context)
def edit_entry(request, entry_id):
'''编辑既有条目'''
entry = Entry.objects.get(id=entry_id)
topic = entry.topic
if topic.owner != request.user:
raise Http404
if request.method != 'POST':
form = EntryForm(instance=entry)
else:
form = EntryForm(data=request.POST, instance=entry)
if form.is_valid():
form.save()
return redirect(reverse('blog:topic', args=[topic.id]))
context = {'form': form, 'title': '编辑条目页面', 'topic': topic, 'entry': entry}
return render(request, 'blog/edit_entry.html', context)
def new_entry(request, topic_id):
topic = Topic.objects.get(id=topic_id)
if topic.author != request.user: raise Http404
if request.method != 'POST':
# 未提交数据：创建一个新表单
form = EntryForm()
else:
# POST提交的数据，对数据进行处理
form = EntryForm(data=request.POST)
if form.is_valid():
new_entry = form.save(commit=False)
new_entry.topic = topic
new_entry.save()
return HttpResponseRedirect(reverse('blog:topic', args=[topic_id]))
context = {'topic': topic, 'form': form}
return render(request, 'blog/new_entry.html', context)
def new_entry(request, topic_id):
'''添加新条目'''
topic = Topic.objects.get(id=topic_id)
if topic.owner != request.user:
raise Http404
if request.method != 'POST':
form = EntryForm()
else:
form = EntryForm(request.POST)
if form.is_valid():
new_entry = form.save(commit=False)
new_entry.topic = topic
new_entry.save()
return redirect(reverse('blog:topic', args=[topic_id]))
context = {'form': form, 'title': '条目创建页面', 'topic': topic}
return render(request, 'blog/new_entry.html', context)
def create_edit(entry_id=None, entry=None):
form = EntryForm()
errors = None
if request.method == 'POST':
if form.validate_on_submit():
if entry_id == None:
entry = Entry(title=form.title.data,
body=form.body.data,
is_published=form.is_published.data)
db.session.add(entry)
db.session.commit()
flash('Dodano nowy post')
else:
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
form.populate_obj(entry)
db.session.commit()
flash('Zaktualizowano post')
else:
errors = form.errors
return render_template("entry_form.html", form=form, errors=errors)
def generate_post(entry_id=None):
if entry_id:
entry = Entry.query.filter_by(id=entry_id).first_or_404()
form = EntryForm(obj=entry)
else:
form = EntryForm()
errors = None
if request.method == 'POST':
if form.validate_on_submit():
if entry_id:
form.populate_obj(entry)
flash('Post changed', 'success')
else:
entry = Entry(title=form.title.data,
body=form.body.data,
is_published=form.is_published.data)
db.session.add(entry)
flash('Post created', 'success')
db.session.commit()
else:
errors = form.errors
return render_template("entry_form.html", form=form, errors=errors)
def edit(request, entry_id):
e = get_object_or_404(Entry, id=entry_id)
if request.user.id == e.author.id:
if request.POST:
entryform = EntryForm(request.POST)
if entryform.is_valid():
entryform.save_as(request, e)
messages.add_message(request, messages.WARNING,
'Your post is waiting for approvement.')
return HttpResponseRedirect('/')
else:
entryform = EntryForm({'title': e.title, 'content': e.content})
return render_to_response('edit.html', {
'entry_id': entry_id,
'form': entryform
}, RequestContext(request))
else:
messages.add_message(
request, messages.ERROR,
'You can not edit this post, because you are not the author of it.'
)
return HttpResponseRedirect('/')
