def post_new(request):
args = {}
if request.method == 'POST':
form = PostForm(request.POST or None, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
i=0
ingredients1 = Ingredient.objects.all()
post.published_date = timezone.now()
print(request.POST.getlist('quantity'))
for item in request.POST.getlist('quantity'):
i=i+1
if int(item) !=0:
w = Wasted.objects.all().get(pk=i)
w.weight = int(item)
w.save()
if Ingredient.objects.all().get(name=w.name, pk=i).weight >0:
ingr = Ingredient.objects.all().get(name=w.name, pk=i)
ingr.weight = ingr.weight - w.weight
ingr.save()
else:
args['login_error'] = "нет на складе продукта"
args['login_error'] = args['login_error']+w.name
return render_to_response('post_new', args)
post.save()
form.save_m2m()
# post.ingredients()
return redirect('post_detail', pk=post.pk)
else:
form = PostForm()
posts = Ingredient.objects.all()
return render(request, 'blog/post_edit.html', {'form': form, 'posts': posts})
def post_edit(request, pk):
post = get_object_or_404(Post, pk=pk)
if request.method == "POST":
form = PostForm(request.POST or None, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
posts = Ingredient.objects.all()
post_numder = post.pk
for ing in request.POST.getlist('ingredients'):
theing = Ingredient.objects.get(pk=ing)
post.ingredients.add(theing.id)
post.save()
form.save_m2m()
# messages.success(request, "<a href='#'>Item</a> Saved", extra_tags='html_safe')
# return HttpResponseRedirect(instance.get_absolute_url())
context = {
"title": post.title,
"instance": post,
"form": form,
"posts":posts,
}
# return render(request, 'blog/post_edit.html', context)
return redirect('post_detail', pk=post.pk)
else:
form = PostForm(instance=post)
posts = Ingredient.objects.all()
return render(request, "blog/post_edit.html", {'form': form, 'posts': posts})
def edit_blog_post(request, post_id, post_slug):
"""Render the page edit an existing post."""
post = get_object_or_404(Post, id=post_id, slug=post_slug)
current_user = request.user
# Only the author can edit the post, and the author must still be listed
# as a contributor.
if (current_user != post.author or
current_user not in post.blog.authors.all()):
raise Http404
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
return save_post_and_redirect(form, request)
else:
form = PostForm(instance=post)
form.fields['author'].widget = forms.HiddenInput()
# Limit blogs dropdown to those the current user can edit
blogs = Blog.objects.filter(authors__in=[current_user])
form.fields['blog'].queryset = blogs
context = {'form': form, 'post': post}
return render(request, 'edit_post.html', context)
def new_blog_post(request):
"""Render the page to create a new post."""
current_user = request.user
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
# TODO: I think this check is overkill, but maybe good to have
if (current_user != form.cleaned_data['author'] or
current_user not in
form.cleaned_data['blog'].authors.all()):
raise Http404
return save_post_and_redirect(form, request)
else:
blogs = Blog.objects.filter(authors__in=[current_user])
if 'blog' in request.GET:
blog = get_object_or_404(Blog, slug=request.GET.get('blog'))
if blog not in blogs:
blog = None
else:
blog = None
form = PostForm(initial={'blog': blog, 'author': current_user})
form.fields['author'].widget = forms.HiddenInput()
form.fields['blog'].queryset = blogs
context = {'form': form}
return render(request, 'new_post.html', context)
def view_post(request, post_id):
form = PostForm()
blog_post = BlogPost.get_by_id(int(post_id))
if request.method == 'POST':
submitted_form = PostForm(request.POST)
if submitted_form.is_valid():
title = submitted_form.cleaned_data['title']
body = submitted_form.cleaned_data['body']
comment = Comment(title=title, body=body,
parent=blog_post)
comment.put()
return redirect(request.path)
else:
form = submitted_form
comments = Comment.all()
comments.ancestor(blog_post.key())
comments.order('-created')
return render(request, 'post_detail.html', {
'post': blog_post,
'comments': comments,
'form': form,
'auth_string': _get_auth_string(request.path),
'current_user': users.get_current_user(),
'is_admin': users.is_current_user_admin(),
})
def edit(request, pk):
post = get_object_or_404(Post, pk=pk)
# 수정하려는 사용자와 작성한 유저가 다르면 에러
if post.author != request.user:
pass
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save()
# post = form.save(commit=False)
# post.author = request.user
# post.save()
# 만약 폼에서 지정하지 못한 필수 필드가 있다면 아래와 같이
# 서버딴에서 필수 필드의 기본값을 설정하여 주는 방법으로 해결
# post = form.save(commit=False)
# post.category = get_object_or_404(Category, pk=1)
# post.save()
# return redirect('blog:detail', post.pk)
# models.py에서 get_absolute_url 함수가 정의된 경우 post만 넘겨도 가능하다.
return redirect(post)
else:
form = PostForm(instance=post)
return render(request, "blog/form.html", {"form": form})
def new(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.ip = request.META['REMOTE_ADDR']
# AWS Load Balancer 를 쓸 경우
# settings.USE_X_FORWARDED_HOST = True 여야,
# HTTP_X_FORWARDED_HOST META 정보에 값이 설정됩니다.
# post.ip = request.META['HTTP_X_FORWARDED_HOST']
post.save()
# post.author = request.user
# post = form.save(commit=False)
# post.category = get_object_or_404(Category, pk=1)
# post.save()
return redirect(post)
else:
form = PostForm()
return render(request, 'blog/form.html', {
'form': form,
})
def edit(request, pk=0, template_name="blog/edit.html"):
""" Edit a post """
user = request.user
post = None
posts = Post.objects.all()
if request.user.is_superuser:
if pk:
post = get_object_or_404(Post, pk=pk)
posts = Post.objects.exclude(id=post.pk)
posts = posts.filter(status__in=['draft', 'published'])
else:
if pk:
post = get_object_or_404(Post, pk=pk, user=request.user)
posts = Post.objects.exclude(id=post.pk)
posts = posts.filter(user=request.user,status__in=['draft', 'published'])
posts = posts.order_by('-pk')
if post:
user = post.user
kwargs = dict(instance=post,user=user,initial={'publish_dt':datetime.datetime.now()})
form = PostForm(request.POST or None, **kwargs)
if request.POST and form.is_valid():
post = form.save()
messages.success(request,'Edited post "%s".' % post)
return HttpResponseRedirect("/blog/admin/edit/%s/"%post.id)
values = {
'form': form,
'post': post,
'posts': posts,
}
return TemplateResponse(request, template_name, values)
def post_new(request):
# ImageFormSet = modelformset_factory(Resource, form=ResourceForm, extra=3)
if request.method == "POST":
postForm = PostForm(request.POST)
formset = ResourceForm(request.POST, request.FILES)
if postForm.is_valid():
post = postForm.save(commit=False)
post.author = request.user
post.save()
for image in request.FILES.getlist("images", []):
# img = image_resizing(image)
photo = Resource(post=post, image_file=image)
photo.save()
return redirect('blog.views.post_detail', pk=post.pk)
# for form in formset.cleaned_data:
# image = form['image_file']
# photo = Resource(post=post, image_file=image)
# photo.save()
else:
postForm = PostForm()
formset = ResourceForm()
return render(request, 'blog/post_edit.html', {'postForm': postForm, 'formset': formset}, context_instance=RequestContext(request))
def post_update(request, post_id=None):
if not post_id:
return redirect('blog:index')
title = 'DevInCafe | UPDATE'
context = {
'WEB_TITLE': title,
}
try:
post = Post.objects.get(id=post_id, author=request.user)
except ObjectDoesNotExist:
return redirect('blog:index')
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return redirect('blog:index')
else:
form = PostForm(instance=post)
context.update({'form': form})
return render(request, 'blog/pages/add_post.html', context)
def post_edit(request, pk):
# To check that the post is existing or not
post = get_object_or_404(Post, pk=pk)
# post = Post.objects.get(pk=pk)
# To check about user
if request.user != post.author:
return redirect('blog.views.errors')
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
# post.published_date = timezone.now()
post.save()
if request.FILES.getlist("images", []):
for resource in post.resources.all():
resource.delete()
for image in request.FILES.getlist("images", []):
photo = Resource(post=post, image_file=image)
photo.save()
return redirect('blog.views.post_detail', pk=post.pk)
else:
return redirect('blog.views.post_detail', pk=post.pk)
else:
postForm = PostForm(instance=post)
formset = ResourceForm(instance=post)
return render(request, 'blog/post_edit.html', {'postForm': postForm, 'formset': formset}, context_instance=RequestContext(request))
def add_edit_post(request, slug=None):
if request.method == 'GET':
form = PostForm()
if slug: # If editing
post = get_object_or_404(Post, slug=slug)
if request.user.is_staff or request.user == post.author:
form = PostForm(instance=post)
else:
raise PermissionDenied
else: # POST
if not slug:
form = PostForm(request.POST)
else:
form = PostForm(request.POST, instance=get_object_or_404(Post, slug=slug))
if form.is_valid():
instance = form.save(commit=False)
if not getattr(instance, 'author'):
instance.author = request.user
if not request.user.is_staff:
instance.approved = False
instance.text = clean_untrusted_tags(instance.text)
instance.save()
form.save_m2m()
return render(request, 'add_post_success.html', {})
return render(request, 'add_edit_post.html', {
'form': form,
'edit': slug is not None
})
def update(request, id):
form = PostForm(request.POST, instance=Post.objects.get(pk=id))
if form.is_valid():
post = form.save()
post.add_tags(request.POST['tags'])
return redirect(post.uri())
return render(request, 'blog/edit.html', {'post':post})
def show_index(request):
user = User.objects.get(username='******')
context = {}
if request.method == 'POST':
form = PostForm(request.POST)
context['form'] = form
#import pdb;pdb.set_trace()
if form.is_valid():
title = form.cleaned_data['title']
text = form.cleaned_data['text']
post = Post(title=title, text=text)
post.author = user
post.save()
return redirect(reverse('posts-index'))
else:
form = PostForm()
context['form'] = form
posts = Post.objects.all()
context['posts'] = posts
#return HttpResponse(json.dumps(data), content_type='application/json')
return render(request, 'posts.html', context)
def create_post(request, slug):
blog = get_object_or_404(Blog, slug=slug)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
slug = generate_slug(post.title)
conflicts = Post.objects.filter(slug__startswith=slug)
if conflicts:
slug = get_unique_slug(slug, conflicts)
post.slug = slug
post.author = request.user
post.blog = blog
post.save()
# We don't want to start sending garbage requests while testing,
# and we only want to do this on the first save of a published post,
# not every update, otherwise we might get IP banned.
if not settings.DEBUG:
post.send_pingbacks()
return redirect('view_post', post.created.year, post.get_formatted_month(), post.slug)
else:
form = PostForm()
context = {
'blog': blog,
'post_form': form,
}
return render_to_response('blog/create_post.html', context, RequestContext(request))
def post(self, request, *args, **kwargs):
print "post"
create_post = PostForm(request.POST)
if create_post.is_valid():
print "valid"
create_post.save()
return HttpResponseRedirect("/")
def admin_edit_post(request, post_id):
if users.is_current_user_admin():
post = Post.get_by_id(int(post_id))
if not post:
raise Http404
if request.method == 'GET':
tp = Tag_Post.all().filter('post', post)
tags = ''
# Get all tags
for tag in tp:
tags += tag.tag.title + ','
form = PostForm({'title':post.title, 'category':post.category.key(), 'content':post.content, 'tags':tags})
elif request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
# delete related tag_post
for tp in post.tags:
tp.delete()
p = form.save(commit=False)
post.author = users.get_current_user()
post.category = p.category
post.content = p.content
post.put()
# add tag_post
tagText = request.POST['tags']
if tagText:
tags = tagText.split(',')
for tag in tags:
if tag:
tag = string.lower(string.strip(tag))
t = Tag.all().filter("title = ", unicode(tag, "utf-8")).get()
if not t:
t = Tag(title=unicode(tag, "utf-8"))
t.put()
Tag_Post(tag=t, post=post).put()
return HttpResponseRedirect('/admin')
return render_to_response('admin/edit.html',
dictionary={ 'form':form,
'type': 'Edit Post',
},
context_instance=RequestContext(request)
)
else:
return HttpResponseRedirect('/')
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('add_post.html',{ 'form': form },context_instance=RequestContext(request))
def post(self, request, slug):
form = PostForm(request.POST, instance=self.postobj, request=request)
if form.is_valid():
newpost = form.save()
return HttpResponseRedirect(reverse('post', args=[newpost.slug,]))
return render(request, self.template_name, {
'form': form
})
def add_post(request):
form = PostForm(request.POST or None)
if form.is_valid():
post = form.save(commit=False)
post.id = None
post.author = request.user
post.save()
return redirect('/blog/archive')
return render(request, 'blog/add_post.html', {'form': form})
def create(request):
form = PostForm(request.POST)
if form.is_valid():
post = form.save()
post.add_tags(request.POST['tags'])
return redirect(post.uri())
else:
logging.error(form.errors)
return render(request, 'blog/edit.html', {'post':form.instance})
def post_new(request):
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
post = form.save()
return redirect('blog:post_detail', post.pk)
else:
form = PostForm()
return render(request, 'blog/post_form.html', {'form':form,})
def add(self, request, *args, **kwargs):
form = PostForm(data=request.POST if request.POST else None, files=request.FILES if request.POST else None)
if form.is_valid():
post = form.save(commit=False)
post.blog = request.blog
post.user = request.user
post.save()
return HttpResponseRedirect(request.blog.get_url())
return {"post_add_form": form}
def add_post(request,blog):
post=Post(author=request.user)
form=PostForm(data=request.POST or None, instance=post)
if form.is_valid():
post=form.save()
return HttpResponseRedirect('/blog/preview/%d/'%post.id)
return render_to_response('blog/edit_post.html',
{'form':form,},
context_instance = RequestContext(request))
def post_new(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
return redirect('index')
else:
return redirect('post_edit')
return render_to_response('blog/post_edit.html', {'form': form}, RequestContext(request))
def edit_post(request, post_id):
blog_entry = get_object_or_404(BlogEntry, pk=post_id)
if request.method == 'POST':
form = PostForm(request.POST, instance=blog_entry)
if form.is_valid():
form.save()
return render_to_response('viewpost.html', {'blog_entry': blog_entry})
form = PostForm(instance=blog_entry)
csrfContext = RequestContext(request, {'form':form, 'blog_entry':blog_entry})
return render_to_response('editpost.html', csrfContext)
def form2(request):
if request.method == 'GET':
return render(request, 'form2.html', { 'form' : PostForm(), 'site_header' : 'THIS' })
elif request.method == 'POST':
form_post = PostForm(request.POST)
if form_post.is_valid():
form_post.save()
return redirect('/blog/')
return render(request, 'form2.html', { 'form' : form_post })
def post_edit(request, pk):
post = get_object_or_404(Post, pk=pk)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
post = form.save()
return redirect(post)
else:
form = PostForm(instance=post)
return render(request, 'blog/post_new.html', {'form':form})
def add_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
post = Post.objects.get(title=form.cleaned_data['title'])
return HttpResponseRedirect(reverse('blog.views.get_post',args=(post.slug,)))
else:
form = PostForm()
return render_to_response('post_form.html', {'form':form, 'new':True}, RequestContext(request))
def create_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
blog_entry = form.save()
return render_to_response('viewpost.html', {'blog_entry': blog_entry})
else:
form = PostForm()
csrfContext = RequestContext(request, {'form':form})
return render_to_response('createpost.html', csrfContext)
def post_edit(request, pk):
resp, form = None, None
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.author = request.user
if post.published_date is None:
post.publish()
else:
post.save()
resp = redirect('post_detail', pk=post.pk)
if form is None:
form = PostForm(instance=post)
if resp is None:
resp = render(request, 'blog/post_edit.html', {'form': form})
return resp
def post_edit(request, pk):
if request.method == "POST":
post = Post.objects.get(id=pk)
form = PostForm(request.POST, request.FILES)
if form.is_valid():
post.title = request.POST.get("title")
post.content = request.POST.get("content")
post.author = request.POST.get("author")
post.picture = request.FILES.get("picture") or post.picture
post.save()
return redirect('home')
else:
post = Post.objects.get(id=pk)
form = PostForm(instance=post)
return render(request=request,
template_name="form.html",
context={
'form': form,
'title': 'Editar Post'
})
def post_update(request, pk):
post = get_object_or_404(Post, pk=pk)
# If request is POST, create a bound form(form with data)
if request.method == "POST":
f = PostForm(request.POST, instance=post)
# check whether form is valid or not
# if the form is valid, save the post in the database
# and redirect the user back to the update post form
# If form is invalid show form with errors again
if f.is_valid():
# if author is not selected and user is superuser, then assign the post to the author named staff
if request.POST.get('author') == "" and request.user.is_superuser:
updated_post = f.save(commit=False)
author = Author.objects.get(user__username='******')
updated_post.author = author
updated_post.save()
f.save_m2m()
# if author is selected and user is superuser
elif request.POST.get('author') and request.user.is_superuser:
updated_post = f.save()
# if user is not a superuser
else:
updated_post = f.save(commit=False)
updated_post.author = Author.objects.get(
user__username=request.user.username)
updated_post.save()
f.save_m2m()
messages.add_message(request, messages.INFO, _('Post updated.'))
return redirect(reverse('post_update', args=[post.id]))
# If request is GET the show unbound form to the user, along with data
else:
f = PostForm(instance=post)
return render(request, 'cadmin/post_update.html', {
'form': f,
'post': post
})
def updatePost(request, pk):
ImageFormSet = modelformset_factory(Images, form=ImageForm, extra=2)
post = get_object_or_404(Post, pk=pk)
old_images = Images.objects.filter(post=post)
#check authorization of user
if post.author != request.user:
messages.success(request,
"You are not authorized to update this post!")
return HttpResponseRedirect("/")
#if request is POST, update both the forms
if request.method == 'POST':
postForm = PostForm(request.POST)
formset = ImageFormSet(request.POST,
request.FILES,
queryset=Images.objects.none())
if postForm.is_valid() and formset.is_valid():
post.title = postForm.cleaned_data['title']
post.content = postForm.cleaned_data['content']
post.topic = postForm.cleaned_data['topic']
post.save()
old_images.delete()
for form in formset.cleaned_data:
if form:
image = form['image']
photo = Images(post=post, image=image)
photo.save()
messages.success(request, "Post Updated!")
return HttpResponseRedirect("/")
else:
messages.success(request, "Post Not Updated! Upload all Images")
return HttpResponseRedirect("/")
#if request is GET, return both the forms with Initial values
else:
postForm = PostForm(instance=post)
formset = ImageFormSet(queryset=Images.objects.filter(post=post))
context = {'postForm': postForm, 'formset': formset}
return render(request, 'blog/post_form.html', context)
def create_or_update_my_posts(request, pk=None):
post_details = None
form_type = "new"
if pk is not None:
form_type = "edit"
form = None
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
# create
if pk is None:
post = form.save(commit=False)
post.author = request.user
post.save()
pk = post.pk
# update
else:
title = form.cleaned_data.get("title")
text = form.cleaned_data.get("text")
# update the data
post_details = Post.objects.get(pk=pk)
post_details.title = title
post_details.text = text
post_details.save()
# redirect to show current updated or created post
return HttpResponseRedirect(
reverse("blog:post_list_selected", kwargs={'pk': pk}))
else:
# Create
if pk is None:
form = PostForm()
# update : Show edit from for post related to pk
else:
post_details = Post.objects.get(pk=pk)
form = PostForm(instance=post_details)
posts = Post.objects.filter(author=request.user)
return render_post(request, posts, form, form_type, pk)
def post_edit(request, slug=None):
if not request.user.is_staff or not request.user.is_superuser:
raise Http404
instance = get_object_or_404(Post, slug=slug)
form = PostForm(request.POST or None,
request.FILES or None,
instance=instance)
if form.is_valid():
instance = form.save(commit=False)
instance.user = request.user
instance.save()
messages.success(request, "Saved")
return HttpResponseRedirect(instance.get_absolute_url())
context = {
'title': instance.title,
'instance': instance,
'form': form,
}
return render(request, 'blog/post_new.html', context)
def post_add(request):
# If request is POST, create a bound form (form with data)
if request.method == "POST":
f = PostForm(request.POST)
# check whether form is valid or not
# if the form is valid, save the data to the database
# and redirect the user back to the add post form
# If form is invalid show form with errors again
if f.is_valid():
# save data
f.save()
messages.add_message(request, messages.INFO, 'Post added.')
return redirect('post_add')
# if request is GET the show unbound form to the user
else:
f = PostForm()
return render(request, 'cadmin/post_add.html', {'form': f})
def post_new(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
print(form.cleaned_data)
#방법1
# post = Post(author = request.user,
# title = form.cleaned_data['title'],
# text = form.cleaned_data['text'],
# published_date = timezone.now())
# post.save()
#방법2
post = Post.objects.create(author=request.user,
title=form.cleaned_data['title'],
text=form.cleaned_data['text'],
published_date=timezone.now())
return redirect('post_detail', pk=post.pk)
else:
form = PostForm()
return render(request, 'blog/post_edit.html', {'form': form})
def post_edit(request, pk):
# 글을 수정해야 하기 때문에 기존에 입력되어 있던 자료를 가져오는게 먼저임.
post = get_object_or_404(Post, pk=pk)
# get방식 post방식 구분
if request.method == "POST":
# post 방식인 경우는 기존 자료 post에 새로 들어온 정보를 덮어씌움.
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
# published_date를 다시 현재 서버시간으로 변경.
post.published_date = timezone.now()
post.save()
return redirect('post_detail', pk=post.pk)
else:
# 만약 post방식이 아닌 경우라면 get방식 이므로 수정 직전임
# 따라서 폼으로 다시 연결해줘야함. 이 떄 의 폼은 수정용 폼이며
# 수정용 폼에는 기존에 써놨었던 글이 먼저 입력되어 있어야 하므로
# 감안해서 기존 글의 내용이 담겨있는 post를 폼에 instance로 넘겨줌
form = PostForm(instance=post)
return render(request, 'blog/post_edit.html', {'form': form})
def post_edit(request, post_id):
if Post.objects.filter(id=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():
post = form.save(commit=False)
words = post.content.split()
if len(words) > 42:
msg = 'Max allowed words are 42.'
return JsonResponse({'message': msg})
post.save()
return redirect(post.get_absolute_url())
elif post.author.user.username == request.user.username:
form = PostForm(instance=post)
return render(request, 'blog/post/create_post.html',
{'form': form})
else:
return JsonResponse({'message': 'You can\'t edit this post'})
else:
return JsonResponse({'message': 'Post not found'})
def new(request):
print("---- new ----")
print("request.GET = {}".format(request.GET))
print("request.POST = {}".format(request.POST))
print("request.FILES = {}".format(request.FILES))
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
title = form.cleaned_data['title']
content = form.cleaned_data['content']
post = Post(title=title, content=content)
post.save()
messages.info(request, "새 글이 등록되었습니다.")
return redirect('blog.views.index')
else:
form = PostForm()
return render(request, "blog/form.html", {
'form': form,
})
def post_update_form_view(request, id):
# print(request.method)
# print(request.GET)
post = Post.objects.get(id=id)
if request.method == "GET":
form = PostForm(instance=post)
return render(request, "blog/post.html", context={"form": form})
else:
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
form.save()
return HttpResponse("Thank you for submitting the response")
else:
print(form.errors)
return render(request, "blog/post.html", context={"form": form})
# blog
# \static
# \blog
# images
# a.jpeg
# 127.0.0.1:8000/static/a.jpeg
# Post.objects.create(title = "",content = "")
# def prinval(val1,val2,val3):
# d = {"val1":10,"val2":20,"val3":30}
# printval(**d)
# cleaned_data => dict
# {% url 'home' %}
# reverse('home')
# reverse_lazy("home")
def post_add(request):
# if request is POST, create a bound form (form with data)
if request.method == "POST":
f = PostForm(request.POST)
# check whether form is valid
# if valid, save data to database
# redirect user back to add post form
# if form is invalid show form with errors
if f.is_valid():
# if author is not selected and user is superuser, then assign the post to the author named admin
if request.POST.get('author') == "" and request.user.is_superuser:
new_post = f.save(commit=False)
author = Author.objects.get(user__username='******')
new_post.author = author
new_post.save()
f.save_m2m()
# if author is selected and user is superuser
elif request.POST.get('author') and request.user.is_superuser:
new_post = f.save()
# if user is not a superuser
else:
new_post = f.save(commit=False)
new_post.author = Author.objects.get(
user__username=request.user.username)
new_post.save()
f.save_m2m()
messages.add_message(request, messages.INFO, 'Post Added')
return redirect('post_add')
# if request is GET then show unbound form to user
else:
f = PostForm()
return render(request, 'cadmin/post_add.html', {'form': f})
def post_update(request, pk):
post = get_object_or_404(Post, pk=pk)
# if request is POST, create a Bound form
if request.method == "POST":
f = PostForm(request.POST, instance=post)
# Check whether form is valid or not
# If form is valid, save the data to the database.
# and redirect the user back to the update post form.
if f.is_valid():
f.save()
messages.add_message(request, messages.INFO, 'Post Updated.')
return redirect(reverse('post_update', args=[post.id]))
# if request is GET the show unbound form to the user, along with data
else:
f = PostForm(instance=post)
return render(request, 'cadmin/post_update.html', {
'form': f,
'post': post
})
def create_post(request):
auser = request.user
if auser.is_authenticated:
if request.method == 'POST':
pform = PostForm(request.POST)
if pform.is_valid():
f_title = request.POST['title']
f_content = request.POST['content']
f_author = auser
f = Post(title=f_title, content=f_content, author=f_author)
f.save()
return redirect('blog:blog-index')
else:
return redirect('blog:blog-about')
else:
return render(request, 'blog/create_post.html',
{'form_np': PostForm()})
else:
return redirect('accounts:accounts-login')
def post_edit(request, pk):
## use 'get_object_or_404' to take you to the post if it is exist, if not send you to 404 page
post = get_object_or_404(Post, pk=pk)
if request.method == 'POST':
# use 'instance' way because we need to update existing form not create new one
form = PostForm(request.POST, instance=post)
if form.is_valid():
# to create the post data inside the data base but not save it yet
post = form.save(commit=False)
# to set the author to who ever create the post
post.author = request.user
# to set the publish date to time we create the post
#post.published_date = timezone.now()
# to save the post date inside the data base
post.save()
# to take you to post detail page when you submit the post
# we add redirect to take you in other page, because if you refresh the page will let you create the post again, need to use redirect method in case you have page of checkout because you don't want to pay money every time you refresh the page
return redirect('post_detail', pk=post.pk)
else:
form = PostForm(instance=post)
stuff_for_frontend = {'form': form, 'post': post}
return render(request, 'blog/post_edit.html', stuff_for_frontend)
def edit_post(request, slug):
post = get_object_or_404(Post, slug=slug)
form = PostForm(Post, instance=post)
if request.user == post.author:
if request.method == "POST":
request.POST = request.POST.copy()
request.POST['author'] = request.user.pk
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
form.save()
else:
import pdb
pdb.set_trace()
template = "blog/posts/edit_post.html"
context = {"form": form, "post": post}
return render(request, template, context)
else:
import pdb
pdb.set_trace()
def new_post(request):
# Http 请求包括 POST 和 GET 两种，一般提交数据都是用 POST 请求
# 因此当 request.method 为 POST 的时候才需要处理表单数据
if request.method == 'POST':
# 用户提交的信息存在 request.POST 中，相当于一个字典取值
form = PostForm(request.POST)
# 判断表单是否有效，django 自动校验表单数据是否合理，根据模型的字段类型来判断
if form.is_valid():
# commit=False 表示只生成模型类的实例，不马上保存到数据库
post = form.save(commit=False)
# 将作者和文章进行关联
post.author = request.user
# 通过调用 save() 方法将数据存入数据库
post.save()
# return render('post_detail', pk=post.pk)
# 如果模型类中定义了 get_absolute_url 方法，可以用以下方式跳转
# 会直接跳转 get_absolute_url 方法所指向的地址
return redirect(post)
else:
# 如果不是 POST 重定向到空白的新建页面
form = PostForm()
return render(request, 'blog/post_new.html', locals())
def post_new(request):
# request.method는 현재 이 함수를 실행하기 위해 들어온 요청이
# POST 방식이라면 문자열 "POST"를 , GET방식이라면 "GET"
# 를 출력한다. 따라서 POST 방식인지를 구분부터 해준다.
if request.method == "POST":
# form 변수에 빈 칸이 채워진 Form 양식을 받아옴
form = PostForm(request.POST)
# .is_valid()는 form에서 요청한 자료가 모두 기입되었는지
# 체크한느 매서드, 만약 모두 기입되지 않았다면 False
# 모두 기입되었다면 True를 반환한다.
if form.is_valid():
# .save()는 아무것도 입력을 안하면 DB에 바로
# 데이터를 적재해버리기 때문에 우선 form 양식 이외에
# 작성자, 퍼블리싱 시간을 추가 적재하기 위해 임시로
# DB에 올리기만 하기 위해 commit=False
post = form.save(commit=False)
# 현재 로그인된 유저를 글쓴이 정보에 저장
post.author = request.user
# 퍼블리싱 날짜는 현재 시간으로 저장
post.published_date = timezone.now()
# 모든 작업 완료 후 실제 DB에 저장
post.save()
# POST방식으로 들어왔으며, 자료 적재도 완전히 끝나면
# 쓴 글을 확인할 수 있는 상세페이지로 이동
# redirect('url 패턴', 우아한 url변수명=넣을자료)
return redirect('post_detail', pk=post.pk)
# 폼 작성시 어떤 양식을 따라갈 것인지 지정
# 현재 우리가 forms.py에 작성한 PostForm을 활용해
# 폼을 자동으로 구성할 예정임
else:
# get 방식으로 들어오는 경우는 자료를 반영하지 않고
# 그냥 다시 post방식 작성을 유도하기 위해 폼으로
# 이동시키는 로직 실행
form = PostForm()
# render에서는 먼저 템플릿 파일 연결 후 폼 정보를 가진
# form 변수를 같이 넘겨준다.
return render(request, 'blog/post_edit.html', {'form': form})
def edit_post(request, pk):
if request.method == "GET":
post = Post.objects.get(pk=pk)
category_list = Category.objects.all()
post_list = Post.objects.all()
return render(request, 'admin/post-edit.html', {
'post': post,
'post_list': post_list,
'category_list': category_list
})
p = Post.objects.get(pk=pk)
validate_post = PostForm(request.POST, instance=p)
errors = {}
if validate_post.is_valid():
new_post = validate_post.save(commit=False)
if 'image' in request.FILES:
image_path = p.image.url
try:
os.remove(image_path)
except Exception:
pass
new_post.image = request.FILES['image']
new_post.save()
photos = request.FILES.getlist('photos')
for p in photos:
img = Gal_Image.objects.create(image=p)
new_post.photos.add(img)
return JsonResponse({
"data": 'Post edited successfully',
"error": False
})
for k in validate_post.errors:
errors[k] = validate_post.errors[k][0]
return JsonResponse(errors)
def post_edit(request, pk):
if request.user.is_superuser:
post = get_object_or_404(Post, pk=pk)
else:
query = Post.objects.filter(author=request.user)
post = get_object_or_404(query, pk=pk)
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
if not post.publish_time:
if post.status == 'published':
post.publish_time = timezone.now()
soup = BeautifulSoup(post.text, 'html.parser')
images = soup.find_all('img')
para = soup.findAll(text=re.compile('^.+$'))
para = " ".join(para)
post.excerpt_text = para[0:500]
# para = " ".join(para)
if images:
imageUrl = images[0].get('src')
post.home_image = imageUrl
post.updated = timezone.now()
print("###################################")
post.save()
return HttpResponseRedirect(reverse('blog:dashboard'))
else:
return render(request, 'blog/post_edit.html', {'form': form})
# return JsonResponse(form.errors,status=400)
else:
form = PostForm(instance=post)
return render(request, 'blog/post_edit.html', {'form': form})
def post_add(request):
if request.method == "POST":
request.POST = request.POST.copy()
request.POST["author"] = request.user.pk
# request.POST["status"] = "published"
form = PostForm(request.POST, request.FILES)
# import pdb; pdb.set_trace()
if form.is_valid():
instance = form.save()
# import pdb; pdb.set_trace()
if request.POST["action"] == "published":
return redirect(instance.get_absolute_url())
elif request.POST["action"] == "draft":
return redirect(reverse("blog:my_stories"))
template = "blog/posts/new_post.html"
form = PostForm()
tags = Tag.objects.all()
# import pdb; pdb.set_trace()
categories = PostCategory.approved.all()
context = {"form": form, "categories": categories, "tags": tags}
return render(request, template, context)
def post_new(request):
if request.method == 'POST':
form = PostForm(request.POST)
photo = None
if request.FILES.get('image'):
photo_form = PhotoForm(request.POST, request.FILES)
if photo_form.is_valid():
photo = photo_form.save()
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
post.photo = photo
post.save()
form.save_m2m()
return redirect('blog:post_detail', pk=post.pk)
else:
form = PostForm()
photo_form = PhotoForm()
return render(request, 'blog/post_edit.html', {
'form': form,
'photo_form': photo_form
})
def post_add(request):
if request == 'POST':
f = PostForm(request.POST)
slug = slugify(request.POST['title'])
if f.is_valid():
r = f.save(commit=False)
r.slug = slug
l = len(Post.objects.filter(slug__startswith=slug))
if l:
slug = slugify(slug + ' ' + str(l))
r.slug = slug
r.save()
else:
r.save()
f.save_m2m()
messages.add_message(request, messages.INFO, 'Post added.')
print()
p = Post.objects.get(slug=slug)
return redirect(reverse('blog:post_detail', args=[p.id, p.slug]))
else:
f = PostForm()
return render(request, 'cadmin/post_add.html', {'form': f})
def post_update(request, pk):
post = get_object_or_404(Post, pk=pk)
if request.method == 'POST':
f = PostForm(request.POST, instance=post)
if f.is_valid():
if request.POST.get('author') == '' and request.user.is_superuser:
updated_post = f.save(commit=False)
updated_post.author = Author.objects.get(
user__username='******')
updated_post.save()
f.save_m2m()
elif request.POST.get('author') and request.user.is_superuser:
f.save()
else:
updated_post = f.save(commit=False)
updated_post.author = Author.objects.get(
user__username=request.user.username)
updated_post.save()
f.save_m2m()
messages.add_message(request, messages.INFO, 'Post updated')
return redirect('post_update', pk=pk)
else:
print(f.errors)
#If request is GET, prepopulate with current post data
else:
f = PostForm(instance=post)
return render(request, 'cadmin/post_update.html', {
'form': f,
'post': post
})
def blog_post(request, blog_id):
if request.method == 'GET':
try:
post = get_object_or_404(Post,
id=request.GET.get('id', 0),
blog_id=blog_id)
return JsonResponse({
'status': 0,
'post': {
'title': post.title,
'summary': post.summary,
'text': post.text,
'datetime': post.datetime.strftime('%a %b %d %H:%M:%S %Y')
}
})
except Post.DoesNotExist:
return JsonResponse({'status': -1, 'message': 'not found'})
elif request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
try:
blog = Blog.objects.get(id=blog_id, user=request.user)
except:
return JsonResponse(
{
'status': -1,
'message': 'blog does not exist'
},
status=404)
newPost = Post(title=form.cleaned_data['title'],
summary=form.cleaned_data['summary'],
text=form.cleaned_data['text'],
blog=blog)
newPost.save()
return JsonResponse({'status': 0, 'post_id': newPost.id})
else:
return JsonResponse({'status': -1, 'message': 'can not be empty'})
def admin_add_post(request):
if users.is_current_user_admin():
if request.method == 'GET':
form = PostForm()
elif request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = users.get_current_user()
post.put()
tagText = request.POST['tags']
tags = tagText.split(',')
for tag in tags:
if tag:
tag = string.lower(string.strip(tag))
t = Tag.all().filter("title = ",
unicode(tag, "utf-8")).get()
if not t:
t = Tag(title=unicode(tag, "utf-8"))
t.put()
Tag_Post(tag=t, post=post).put()
return HttpResponseRedirect('/admin')
return render_to_response('admin/edit.html',
dictionary={
'form': form,
'type': 'Add Post',
},
context_instance=RequestContext(request))
else:
return HttpResponseRedirect('/')
def new_post(request, blog_name=None):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
if blog_name:
post.blog = get_object_or_404(Blog, name__iexact=blog_name)
post.author = request.user
post.date_published = timezone.now()
post.save()
return HttpResponseRedirect(reverse('blog:post', args=(post.id, )))
else:
if blog_name:
form = PostForm(
initial={
'blog': get_object_or_404(Blog, name__iexact=blog_name)
})
else:
form = PostForm()
return render(request, 'blog/new_post.html', {'form': form})
def edit_post(
request,
pk,
):
if request.method == "GET":
instance = Post.objects.get(pk=pk)
context = {
'form': PostForm(instance=instance),
'next': request.GET.get('next', reverse('all-blog-posts')),
}
return render(request, 'edit_post.html', context)
elif request.method == "POST":
instance = Post.objects.get(pk=pk)
form = PostForm(request.POST, request.FILES, instance=instance)
if form.is_valid():
form.save()
next = request.GET.get('next', reverse('all-blog-posts'))
return HttpResponseRedirect(next)
context = {
'form': PostForm(request.POST, instance=instance),
}
return render(request, 'edit_post.html', context)
def post_update(request, pk):
post = get_object_or_404(Post, pk=pk)
# If request is POST, create a bound form(form with data)
if request.method == "POST":
f = PostForm(request.POST, instance=post)
# check whether form is valid or not
# if the form is valid, save the data to the database
# and redirect the user back to the update post form
# If form is invalid show form with errors again
if f.is_valid():
f.save()
return redirect(reverse('post_update', args=[post.id]))
# if request is GET the show unbound form to the user, along with data
else:
f = PostForm(instance=post)
return render(request, 'cadmin/post_update.html', {
'form': f,
'post': post
})
