def create():
date = datetime.datetime.now()
form = BlogPostForm()
if form.validate_on_submit():
filename = secure_filename(form.image.data.filename)
form.image.data.save('project/static/images/' + filename)
image_link = 'static/images/' + filename
new_post = BlogPost(
form.title_header.data,
form.title_long.data,
form.content.data,
form.tag.data,
date,
image_link,
current_user.id,
form.author_name_manual.data
)
db.session.add(new_post)
db.session.commit()
flash('New entry was successfully posted. Thanks.')
return redirect(url_for('home.create'))
else:
filename = None
posts = db.session.query(BlogPost).all()
return render_template(
'create.html', posts=posts, form=form, error=error, filename=filename)
def create_update_post(request, pk=None):
post = None
if pk:
post = get_object_or_404(BlogPost, pk=pk)
if not request.user.has_perm("blog.change_blogpost", post):
return HttpResponseForbidden()
else:
if not request.user.has_perm("blog.add_blogpost"):
return HttpResponseForbidden()
# Do an update.
if request.method == 'POST':
form = BlogPostForm(request.POST, instance=post)
if form.is_valid(): # All validation rules pass
post = form.save(commit=False)
post.user = request.user
post.save()
assign('blog.view_blogpost', request.user, post)
assign('blog.change_blogpost', request.user, post)
assign('blog.delete_blogpost', request.user, post)
return redirect(reverse('view_post', args=[post.id]))
else:
form = BlogPostForm(instance=post) # An unbound form
# Return the crud page.
return render_to_response('blog/create_edit_post.xhtml', {
'post': post, 'form': form
}, context_instance=RequestContext(request))
def add_post(request):
if request.method == 'POST':
form = BlogPostForm(request.POST)
if form.is_valid():
new_post = BlogPost(
title=form.cleaned_data['title'],
content=form.cleaned_data['content'],
published=True,
author=request.user
)
new_post.save()
return redirect('view_posts', post_id=new_post.id)
else:
form = BlogPostForm()
return render(
request,
'add_post.html',
{
'form': form,
}
)
def add_post(request):
'''Add new blogpost'''
form = BlogPostForm(request.POST or None)
if request.method == 'POST' and form.is_valid():
new_post = form.save(commit=False)
new_post.user_id = request.user.id
new_post.save()
if form.cleaned_data['tags']:
list_tags = request.POST['tags'].split(',')
list_tags = [tag.strip() for tag in list_tags]
list_tags = set(list_tags)
if len(list_tags) > 10:
return HttpResponse('Amount of tags can\'t be more than 10!')
for tag in list_tags:
if tag:
new_tag, created = Tag.objects.get_or_create(name=tag)
new_post.tag.add(new_tag.id)
return redirect('blog:list_of_posts')
else:
context = RequestContext(request)
return render_to_response('blog/add_post.html',
{'form': form}, context)
def post(request, post_id=None):
"""
Displays, creates or updates a blog post.
"""
post = None
if post_id:
post = get_object_or_404(BlogPost.objects.all(), pk=post_id)
if request.method == 'POST':
form = BlogPostForm(request.POST, instance=post)
if form.is_valid():
post = form.save()
return SerializeOrRedirect(reverse('list_posts'), { 'post': post })
else:
return SerializeOrRender('blog/post.html', { 'post': post }, extra = { 'form': form }, status=CR_INVALID_DATA)
else:
form = BlogPostForm(instance=post)
return SerializeOrRender('blog/post.html', { 'post': post }, extra={ 'form': form })
def post(self):
form = BlogPostForm(self.request.POST)
if form.validate():
post = BlogPost(**form.data)
post.save()
self.redirect_to("admin-blog-post-edit-extra", post_id = post.key().id(), extra="saved")
return {
"admin_section": "admin-blog-posts-new",
"form": form,
}
def new_post(request):
if request.method == "POST":
form = BlogPostForm(request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
post.save()
return redirect(post_detail, post.pk)
else:
form = BlogPostForm
return render(request, 'blogpostform.html', {'form': form})
def edit_post(request, id):
post = get_object_or_404(Post, pk=id)
if request.method == "POST":
form = BlogPostForm(request.POST, request.FILES, instance=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, post.pk)
else:
form = BlogPostForm(instance=post)
return render(request, 'blogpostform.html', {'form': form})
def editposts():
error = None
form = BlogPostForm()
if request.method == 'POST':
if form.validate_on_submit():
new_post = Post(
form.subject.data,
form.header.data,
form.digest.data,
form.body.data,
)
db.session.add(new_post)
db.session.commit()
flash(u'پست ثبت شد!!')
return render_template('postedit.html', form=form, error=error)
def post():
form = BlogPostForm(request.form)
if request.method == 'POST':
if form.validate():
post = Post(user=form.author.data,
title=form.title.data,
content=form.content.data)
current_session.add(post)
current_session.commit()
flash('Post created!')
return redirect(url_for('post'))
else:
flash('Form is not valid! Post was not created.')
posts = current_session.query(Post).all()
return render_template('post.html', form=form, posts=posts)
def editposts():
error = None
form = BlogPostForm()
if request.method == 'POST':
if form.validate_on_submit():
new_post = Post(
form.subject.data,
form.header.data,
form.digest.data,
form.body.data,
)
db.session.add(new_post)
db.session.commit()
flash(u'پست ثبت شد!!')
return render_template('postedit.html', form=form, error=error)
class BlogPostHandler(BaseHandler):
"""Manage individual blog posts"""
@admin_required
def get(self, post_id=None, **kwargs):
"""Return a post to edit or an empty form to create"""
template = 'admin/blog/new.html'
context = {
'form': self.form,
}
# render edit
if post_id is not None:
post = BlogPost.get_by_id(post_id)
if post:
self.form = BlogPostForm(obj=post)
self.form.tags.data = ', '.join(post.tags)
context.update({'form': self.form})
template = 'admin/blog/edit.html'
else:
return redirect('admin/blog/')
# render new
return self.render_response(template, **context)
@admin_required
def post(self, post_id=None, **kwargs):
"""Handle submitted form data"""
# validate form
if self.form.validate():
title = self.form.title.data
lead = self.form.lead.data
content = self.form.content.data
live = self.form.live.data
tags = self.form.tags.data
language = self.form.language.data
if tags is not None:
tags = [tag.strip() for tag in tags.split(',') if tag != '']
# saving edited
if post_id:
post = BlogPost.get_by_id(post_id)
post.title = title
post.lead = lead
post.content = content
post.live = live
post.tags = tags
post.language = language
# creating new
else:
post = BlogPost(title=title,
lead=lead,
content=content,
live=live,
tags=tags,
language=language)
if post.put():
return redirect('admin/blog')
return self.get(**kwargs)
@cached_property
def form(self):
"""Form instance as cached_property"""
return BlogPostForm(self.request)
def post(self, post_id, extra=""):
form = BlogPostForm(self.request.POST)
success = False
post = BlogPost.get_by_id(long(post_id))
if form.validate():
form.populate_obj(post)
post.save()
success = True
return {
"admin_section": "admin-blog-posts",
"form": form,
"success": success,
"post": post,
}
def new(request, template_name='blog/new_or_edit.html'):
if request.method == 'POST':
form = BlogPostForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect("/")
else:
form = BlogPostForm()
template_context = {'form': form}
return render_to_response(
template_name,
template_context,
RequestContext(request)
)
def save():
form = BlogPostForm()
if form.validate_on_submit():
if request.form['action'] == 'draft':
print('Saving to redis')
redis_client.set(form.title.data, form.body.data)
else:
print('Saving to postgres')
model = Post()
model.title = form.title.data
model.body = form.body.data
model.date = form.date.data
model.author = form.author.data
db.session.add(model)
db.session.commit()
return render_template('new.html', form=form)
def new():
"""
Create a new blog post.
"""
error = None
form = BlogPostForm(request.form)
if request.method == 'POST' and form.validate():
new_blog_post = Post(form.title.data, form.content.data, form.published.data, current_user.get_id())
g.db_session.add(new_blog_post)
flash('New Blog Post Created!')
return redirect(url_for('blog.show_posts'))
try:
return render_template('blog_new.html', form=form, error=error)
except TemplateNotFound:
abort(404)
def home():
storage = Storage()
if request.method == 'POST':
form = BlogPostForm(request.form)
if form.validate():
model = BlogPostModel(form.data)
storage.appending(model.model_to_dict())
else:
logger.error('Someone have submitted an incorrect form!')
else:
form = BlogPostForm()
return render_template(
'home.html',
form=form,
items=storage.posts,
)
def get(self, post_id=None, **kwargs):
"""Return a post to edit or an empty form to create"""
template = 'admin/blog/new.html'
context = {
'form': self.form,
}
# render edit
if post_id is not None:
post = BlogPost.get_by_id(post_id)
if post:
self.form = BlogPostForm(obj=post)
self.form.tags.data = ', '.join(post.tags)
context.update({'form': self.form})
template = 'admin/blog/edit.html'
else:
return redirect('admin/blog/')
# render new
return self.render_response(template, **context)
def new_post():
initialize_json()
post_result = None
if request.method == 'POST':
form = BlogPostForm(request.form)
if form.validate():
new_post = BlogPostModel(form.data)
save_to_json(new_post)
post_result = "Posted successful"
else:
form = BlogPostForm()
return render_template(
'new_post.html',
form=form,
post_result=post_result,
)
def edit(request, slug, template_name='blog/new_or_edit.html'):
post = BlogPost.objects.get(slug=slug)
if request.method == 'POST':
form = BlogPostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return HttpResponseRedirect(post.get_absolute_url())
else:
form = BlogPostForm(instance=post)
template_context = {'form': form}
return render_to_response(
template_name,
template_context,
RequestContext(request)
)
def process_create(self, request, context, *args, **kwargs):
form = BlogPostForm()
if request.POST:
form = BlogPostForm(request.POST)
if form.is_valid():
p = create_post(context['user'], form.cleaned_data)
cache_invalidate('written')
# Serve up the new row
return HttpResponseRedirect(urlresolvers.reverse('admin_plugin_action', args=(context['plugin_slug'], 'posts')))
else:
return FormErrorResponse(form, id='create_form')
target_url = urlresolvers.reverse('admin_plugin_action', args=(context['plugin_slug'], 'create'))
return FormResponse(form, id='create_form', title="Create a new Blog Post", target_url=target_url, target_action='create')
def add_post(request):
context = RequestContext(request)
if request.method == 'POST':
form = BlogPostForm(request.POST)
if form.is_valid():
blog = BlogPost()
blog.author = request.user
blog.title = request.POST['title']
blog.bodytext = request.POST['bodytext']
blog.save()
messages.add_message(request, SUCCESS, 'Post Added')
return HttpResponseRedirect('/main/blog/')
else:
messages.add_message(request, SUCCESS, 'Enter a valid Post')
return HttpResponseRedirect('/main/add/')
else:
form = BlogPostForm()
return render_to_response('blog/add.html', {'form': form}, context)
def profile(id):
form = BlogPostForm()
if id == current_user.id and request.method == 'GET':
posts = current_session.query(Post).filter(
Post.user == current_user).all()
return render_template('post.html', form=form, posts=posts)
elif request.method == 'POST' and id == current_user.id and form.validate(
):
post = Post(user=current_user,
title=form.title.data,
content=form.content.data)
current_session.add(post)
current_session.commit()
flash('post_created')
route_to = '/profile/' + str(current_user.id)
return redirect(route_to)
else:
return redirect(url_for('login_route.login'))
def add_comment(request, blogpost_id, pid=0):
''' add comment to blogpost
pid=0 means that comment haven't any parents comment
'''
form = BlogPostCommentForm(request.POST)
if form.is_valid():
post = get_object_or_404(BlogPost, pk=blogpost_id)
new_comment = form.save(commit=False)
new_comment.user_id = request.user.id
new_comment.post_id = blogpost_id
new_comment.parent_comment = pid
new_comment.save()
post.increment_count_comments()
form = BlogPostForm(request.POST or None)
form = BlogPostForm(request.POST or None)
form = BlogPostForm(request.POST or None)
return redirect(reverse('blog:show_post', args=[blogpost_id]))
class BlogPostHandler(BaseHandler):
"""Manage individual blog posts"""
@admin_required
def get(self, post_id=None, **kwargs):
"""Return a post to edit or an empty form to create"""
template = 'admin/blog/new.html'
context = {
'form': self.form,
}
# render edit
if post_id is not None:
post = BlogPost.get_by_id(post_id)
if post:
self.form = BlogPostForm(obj=post)
self.form.tags.data = ', '.join(post.tags)
context.update({ 'form': self.form })
template = 'admin/blog/edit.html'
else:
return redirect('admin/blog/')
# render new
return self.render_response(template, **context)
@admin_required
def post(self, post_id=None, **kwargs):
"""Handle submitted form data"""
# validate form
if self.form.validate():
title = self.form.title.data
lead = self.form.lead.data
content = self.form.content.data
live = self.form.live.data
tags = self.form.tags.data
language = self.form.language.data
if tags is not None:
tags = [tag.strip() for tag in tags.split(',') if tag != '']
# saving edited
if post_id:
post = BlogPost.get_by_id(post_id)
post.title = title
post.lead = lead
post.content = content
post.live = live
post.tags = tags
post.language = language
# creating new
else:
post = BlogPost(title=title, lead=lead, content=content, live=live, tags=tags, language=language)
if post.put():
return redirect('admin/blog')
return self.get(**kwargs)
@cached_property
def form(self):
"""Form instance as cached_property"""
return BlogPostForm(self.request)
def home():
storage = Storage()
all_items = storage.items
if request.method == 'POST':
form = BlogPostForm(request.form)
if form.validate():
model = BlogPostModel(form.data, len(all_items) + 1)
all_items.append(model)
storage.save()
else:
logger.error('Someone have submitted an incorrect form!')
else:
form = BlogPostForm()
return render_template(
'home.html',
form=form,
items=all_items,
)
def post(request, post_id=None):
"""
Displays, creates or updates a blog post.
"""
post = None
if post_id:
post = get_object_or_404(BlogPost.objects.all(), pk=post_id)
if request.method == 'POST':
form = BlogPostForm(request.POST, instance=post)
if form.is_valid():
post = form.save()
return SerializeOrRedirect(reverse('list_posts'), {'post': post})
else:
return SerializeOrRender('blog/post.html', {'post': post},
extra={'form': form},
status=CR_INVALID_DATA)
else:
form = BlogPostForm(instance=post)
return SerializeOrRender('blog/post.html', {'post': post},
extra={'form': form})
def edit(post_id):
"""
Edit a post.
"""
post = g.db_session.query(Post).filter_by(id=post_id).first()
form = BlogPostForm(request.form)
if request.method == 'POST' and form.validate():
post = g.db_session.query(Post).filter_by(id=post_id).first()
post.title = form.title.data
post.content = form.content.data
post.published = form.published.data
return redirect(url_for('blog.show_posts'))
form.title.data = post.title
form.content.data = post.content
form.published.data = post.published
try:
return render_template('blog_edit.html', form=form, post=post)
except TemplateNotFound:
abort(404)
def create():
date = datetime.datetime.now()
form = BlogPostForm()
if form.validate_on_submit():
filename = secure_filename(form.image.data.filename)
form.image.data.save('project/static/images/' + filename)
image_link = 'static/images/' + filename
new_post = BlogPost(form.title_header.data, form.title_long.data,
form.content.data, form.tag.data, date, image_link,
current_user.id, form.author_name_manual.data)
db.session.add(new_post)
db.session.commit()
flash('New entry was successfully posted. Thanks.')
return redirect(url_for('home.create'))
else:
filename = None
posts = db.session.query(BlogPost).all()
return render_template('create.html',
posts=posts,
form=form,
error=error,
filename=filename)
def new(request, template_name='blog/new_or_edit.html'):
if request.method == 'POST':
form = BlogPostForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect("/")
else:
form = BlogPostForm()
template_context = {'form': form}
return render_to_response(template_name, template_context,
RequestContext(request))
def ajax():
form = BlogPostForm()
if request.method == 'POST': # and form.validate():
post = Post(user=current_user,
title=form.title.data,
content=form.content.data)
print(post)
current_session.add(post)
current_session.commit()
return jsonify(
post.title, post.content, current_user.name
) #{'success':True}), 200, {'ContentType':'application/json'} #, 'Post created!'
if request.method == 'GET':
return jsonify(current_user.name)
return 'Invalid form'
def process_edit(self, request, context, *args, **kwargs):
post_keystr = request.REQUEST['post_key']
if not post_keystr:
raise RuntimeError('No argument post_key provided.')
post_key = ndb.Key(urlsafe=post_keystr)
post = post_key.get()
initial_data = {
'slug': post.slug,
'summary': post.summary,
'title': post.title,
'content': post.content,
'publish': bool(post.published_date),
'categories': [c_key.urlsafe() for c_key in post.categories],
'primary_media_image' : post.primary_media_image.urlsafe() if post.primary_media_image else ''
}
form = BlogPostForm(initial=initial_data)
if request.POST:
form = BlogPostForm(request.POST, initial=initial_data)
if form.is_valid():
p = edit_post(context['user'], post, form.cleaned_data)
cache_invalidate('written')
# Serve up the new row
return HttpResponseRedirect(urlresolvers.reverse('admin_plugin_action', args=(context['plugin_slug'], 'posts')))
else:
return FormErrorResponse(form, id='create_form')
target_url = "%s?post_key=%s" % (urlresolvers.reverse('admin_plugin_action', args=(context['plugin_slug'], 'edit')), post_key.urlsafe())
return FormResponse(form, id='edit_form', title="Edit Blog Post", target_url=target_url, target_action='edit')
def edit(request, slug, template_name='blog/new_or_edit.html'):
post = BlogPost.objects.get(slug=slug)
if request.method == 'POST':
form = BlogPostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return HttpResponseRedirect(post.get_absolute_url())
else:
form = BlogPostForm(instance=post)
template_context = {'form': form}
return render_to_response(template_name, template_context,
RequestContext(request))
def new_post(request):
if request.method == "POST":
form = BlogPostForm(request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
post.save()
return redirect(post_detail, post.pk)
else:
form = BlogPostForm()
return render(request, 'blogpostform.html', {'form': form})
def get(self, post_id=None, **kwargs):
"""Return a post to edit or an empty form to create"""
template = 'admin/blog/new.html'
context = {
'form': self.form,
}
# render edit
if post_id is not None:
post = BlogPost.get_by_id(post_id)
if post:
self.form = BlogPostForm(obj=post)
self.form.tags.data = ', '.join(post.tags)
context.update({ 'form': self.form })
template = 'admin/blog/edit.html'
else:
return redirect('admin/blog/')
# render new
return self.render_response(template, **context)
def edit_post(request, id):
post = get_object_or_404(Post, pk=id)
if request.method == "POST":
form = BlogPostForm(request.POST, request.FILES, instance=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, post.pk)
else:
form = BlogPostForm(instance=post)
return render(request, 'blogpostform.html', {'form': form})
def edit_post(request, pk):
post = get_object_or_404(BlogPost, pk=pk)
context = RequestContext(request)
if not request.user.id == post.user.id:
title = 'Error!'
message = 'You\'re not the author of this post!'
return render_to_response('basesite/notification.html',
{'title': title, 'message': message},
context)
if request.method == "POST":
add_post(request)
else:
form = BlogPostForm()
return render_to_response('blog/add_post.html',
{'form': form,
'post':post.body,
'post_title':post.title,
'post_tags':post.tag
},
context)
def form(self):
"""Form instance as cached_property"""
return BlogPostForm(self.request)
def new():
form = BlogPostForm()
return render_template('new.html', form=form)
