def post_create(request):
# # 로그인이 되어있는 상태인지 확인해야 한다.
# if not request.user.is_authenticated():
# return redirect('member:login')
if request.method == 'POST':
form = PostForm(data=request.POST, files=request.FILES)
if form.is_valid():
# Form 안에서 comment저장을 하기 위해 author를 인수로 할당하고
# 원래 author를 추가로 저장하기 위해 설정했던 commit=False는 삭제
post = form.save(author=request.user)
# PostForm에 comment가 전달되었을 경우 Comment객체 생성
# comment_string = form.cleaned_data['comment']
# if comment_string:
# post.comment_set.create(
# author=request.user,
# content=comment_string,
# )
return redirect('post:post_detail', post_pk=post.pk)
else:
context = {
'form': form,
}
return render(request, 'post/post_create.html', context)
else:
form = PostForm()
context = {
'form': form,
}
return render(request, 'post/post_create.html', context)
def post_create(request):
# 로그인한 유저만 접근 및 POST요청 가능
if not request.user.is_authenticated:
return redirect('member:login')
if request.method == 'POST':
# POST요청의 경우 PostForm인스턴스 생성과정에서 request.POST, request.FILES를 사용
form = PostForm(request.POST, request.FILES)
# 만약 form이 유효성검사를 통과헀다면 true리턴
if form.is_valid():
# 유효할 경우 Post인스턴스를 생성 및 저장
post = Post.objects.create(
author=request.user,
photo=form.cleaned_data['photo'],
)
return redirect('post:post_list')
else:
# GET 요청의 경우 빈 PostForm인스턴스를 생성해서 템플릿에 전달
form = PostForm()
# GET 요청에선 이 부분이 무조건 실행
# POST 요청에선 form.is_valid()를 통과하지 못하면 이 부분이 실행
context = {
'form': form,
}
return render(request, 'post/post_create.html', context)
def post_modify(request, post_pk):
post = Post.objects.get(pk=post_pk)
next = request.GET.get('next')
# if request.method == 'GET':
# forms = ModifyPost(initial={'image': post.image})
# context = {
# 'forms': forms,
# 'post': post,
# }
# return render(request, 'post/post_modify.html', context=context)
#
# elif request.method == 'POST':
# forms = ModifyPost(request.POST, request.FILES)
# if forms.is_valid():
# post.image = request.FILES['image']
# post.save()
# return redirect('post:post_detail', post_pk=post.id)
if request.method == 'POST':
form = PostForm(data=request.POST, files=request.FILES, instance=post)
if form.is_valid():
form.save()
if next:
return redirect(next)
return redirect('post:post_detail', post_pk)
else:
form = PostForm(instance=post)
context = {
'form': form,
}
return render(request, 'post/post_modify.html', context=context)
def post_add(request):
def create_post_comment(file, comment_content):
post = Post(author=request.user, photo=file)
post.save()
if comment_content != '':
post.add_comment(request.user, comment_content)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
files = request.FILES.getlist('photo')
comment_content = form.cleaned_data.get('content', '').strip()
for file in files:
create_post_comment(file, comment_content)
return redirect('post:list')
else:
form = PostForm()
context = {
'form': form,
}
return render(request, 'post/post_add.html', context)
def adminposts(request):
posts = Post.objects.all()
postform = PostForm()
args = {'posts' : posts, 'postform' : postform}
if request.method == "POST":
postform = PostForm(request.POST, request.FILES)
if postform.is_valid():
postform.save()
else:
print("errors : {}".format(postform.errors.as_data()))
return render(request, 'webadmin/pages/database/posts/index.html',args)
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.post_date = timezone.now()
post.save()
return redirect('post:post_detail', post.pk)
else:
form = PostForm(instance=post)
return render(request, 'edit.html', {'form': form})
def save_post(request, post_id=None):
post = post_id is None and Post(user_id=request.user.id) \
or get_object_or_404(Post, id=post_id)
if request.POST:
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return redirect('edit_post', post.id)
else:
form = PostForm(instance=post)
images = Image.objects.filter(user_id=request.user.id)
form.new = post_id is None or False
return render(request, 'post/form.html', {'form': form, 'images': images})
def post_modify(request, post_pk):
post = Post.objects.get(pk=post_pk)
if request.method == "POST":
form = PostForm(data=request.POST, files=request.FILES, instance=post)
if form.is_valid():
form.save()
return redirect('post:post_detail', post_pk=post.pk)
else:
form = PostForm(instance=post)
context = {
'form': form,
}
return render(request, 'post/post_modify.html', context)
def post_modify(request, post_pk):
post = get_object_or_404(Post, pk=post_pk)
if request.method == 'POST':
form = PostForm(data=request.POST, files=request.FILES, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.author = User.objects.first()
post.save()
return redirect('post_list')
else:
form = PostForm(instance=post)
context = {'form': form}
return render(request, 'post/post_modify.html', context=context)
def add(request):
if request.method == "POST":
form = PostForm(request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.post_author = request.user
post.post_date = timezone.now()
post.post_status = 0
post.save()
return redirect('post:post_detail', post.pk)
else:
form = PostForm()
return render(request, 'add.html', {'form': form})
def managepost(request, slug_url):
post = get_object_or_404(Post, slug = slug_url)
postform = PostForm(instance = post)
args = {'postform' : postform, 'post' : post}
if request.method == 'POST':
postform = PostForm(request.POST, request.FILES, instance=post)
if postform.is_valid():
postform.save()
args = {'postform' : postform, 'post' : post}
return redirect('/webmaster/post/'+post.slug)
else:
print("errors : {}".format(postform.errors.as_data()))
return render(request, 'webadmin/pages/manage/post/index.html',args)
def profile(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.save()
return HttpResponseRedirect(reverse('home'))
context = {
'title': 'User',
'form': form
}
return render(request, 'login/user.html', context=context)
def create(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.created_at = timezone.now()
post.save()
pk = post.id
url = reverse('post:detail', kwargs={'pk': pk})
return redirect(to=url)
else:
form = PostForm()
context = {'form': form}
return render(request, 'post/create.html', context)
def post_create(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_post = Post(
title=data['title'],
content=data['content'],
)
new_post.save()
return redirect('/')
context = {'form': form}
return render(request, 'post/post_create.html', context)
def post_create(request):
if request.method == "POST":
post_form = PostForm(request.POST, request.FILES)
if post_form.is_valid():
title = post_form.cleaned_data['title']
photo = post_form.cleaned_data['photo']
content = post_form.cleaned_data['content']
Post.objects.create(title=title, photo=photo, content=content)
return redirect('post_list')
else:
post_form = PostForm()
context = {
'post_form': post_form,
}
return render(request, 'post/post_create.html', context)
def post(self, request):
"""
Valida el formulario de creacion de nuevo post y lo crea.
:param request: objeto HttpRequest con los datos de la peticion
:return:
"""
message = None
post_with_user = Post(owner=request.user)
post_form = PostForm(request.POST, instance=post_with_user)
if post_form.is_valid():
new_post = post_form.save()
post_form = PostForm()
message = "Post creado satisfactoriamente."
context = {"form": post_form, "message": message}
return render(request, "post/new_post.html", context)
def new_post(request):
if request.method == "POST":
form = PostForm(request.POST, request.FILES)
if form.is_valid():
data = form.cleaned_data
time = timezone.now()
new_post = Post.objects.create(author=get_object_or_404(
Author, username=request.user.username),
caption=data["caption"],
image=data['image'],
timestamp=time)
new_post.save()
return redirect(reverse("homepage"))
form = PostForm()
return render(request, "../templates/post/post_form.html", {"form": form})
def post_create(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
comment = form.cleaned_data['comment']
Post.objects.create(
comment=comment,
author=request.user,
)
return redirect('post_list')
else:
form = PostForm()
context = {'form': form}
return render(request, 'post/post_create.html', context)
def add_post(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
cleaned_data = form.cleaned_data
post = Post()
post.title = cleaned_data['title']
post.content = cleaned_data['content']
post.image = cleaned_data['image']
post.save()
return redirect('post-detail', pk=post.pk)
else:
form = PostForm(request.FILES)
return render(request, 'post/post_form.html', {'form': form})
def get_context(self, request):
self.post_instance = get_object_or_404(
Post.objects_from_local_language,
slug_title=self.kwargs.get("title"))
self.content_instance = self.get_instance(
Content, self.kwargs.get("content_pk"))
if self.content_instance:
self.image_instance = self.content_instance.get_image()
print(self.image_instance)
self.post_form = PostForm(instance=self.post_instance)
self.content_form = self.get_form(request,
ContentUpdateForm,
instance=self.content_instance)
self.image_form = self.get_form(request,
ImageForm,
instance=self.image_instance)
context = {
"post_form": self.post_form,
"content_form": self.content_form,
"post_instance": self.post_instance,
"image_form": self.image_form,
"content_pk": self.kwargs.get("content_pk")
}
return context
def post_create(request):
if not request.user.is_authenticated():
return redirect('member:login')
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.save()
return redirect('post:post_list')
else:
form = PostForm() # GET요청의 경우, 빈 PostForm인스턴스를 생성해서 템플릿에 전달
context = {
'form': form,
}
return render(request, 'post/post_create.html', context)
def get(self, request, community_url):
"""
Representation of community page
:param community_url: community custom_url field
:type community_url: str
:param request: object with request details
:type request: :class:`django.http.HttpRequest`
:return: responce object with HTML code
:rtype: :class:`django.http.HttpResponse`
:raises: :class:`django.http.Http404` if custom url not valid
"""
context = self.get_menu_context('community', 'Сообщество')
context['community'] = get_object_or_404(Community,
custom_url=community_url)
post_image_form_set = modelformset_factory(PostImages,
form=PostImageForm,
extra=10,
max_num=10)
context['postform'] = PostForm()
context['formset'] = post_image_form_set(
queryset=PostImages.objects.none())
context['action_type'] = '/post/create/{}/'.format(community_url)
return render(request, self.template_name, context)
def save_post(request):
"""Saves a Post
Check if the post's island exists
If not redirect the user to Island creation page
If no island was included, use the default island.
Add post to user's likes then save the post and
return the user to a page specified with the next variable
"""
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.cleaned_data["post"]
island_name = form.cleaned_data["island"]
if island_name:
try:
island = Island.get_island(island_name)
except ObjectDoesNotExist:
create_form = IslandCreationForm()
return render(
request,
"island/island_not_created.html",
{
"form": create_form,
"submitted_island": island_name
},
)
else:
island = Island.get_island(settings.DEFAULT_ISLAND)
post = Post(post=post, user=request.user, island=island)
post.save()
request.user.likes.add(post)
return HttpResponseRedirect(request.GET.get("next", ""))
def post(self, request, *args, **kwargs):
post = PostForm(request.POST, request.FILES)
if post.is_valid():
post.instance.usuario = request.user
post.save()
return redirect('core:index')
def edit_post(request, post_id=None):
if post_id is not None:
post = get_object_or_404(Post, pk=post_id)
else:
post = None
if request.method == 'POST':
if post and 'delete' in request.POST:
post.delete()
return redirect('posts')
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
post = form.save(request.profile)
return HttpResponseRedirect(post.get_absolute_url())
else:
form = PostForm(instance=post)
return locals()
def create(request):
form = PostForm(request.POST, user=request.user)
if form.is_valid():
post = form.save()
return JsonResponse(post.to_client())
else:
return JsonResponse(form.errors, status=400)
def new_post(request):
if request.method == 'POST':
form = PostForm(data=request.POST, files=request.FILES)
if form.is_valid():
obj = Post(author=request.user,
timestamp=timezone.now(),
description=form.cleaned_data.get('description'),
image=form.cleaned_data.get('image'))
obj.save()
return redirect('/post/%d/' % obj.id)
context = dict()
context['form'] = PostForm()
return render(request, 'post_new.html', context)
def get(self, request, **kwargs: dict) -> render:
if not Profile.objects.filter(custom_url=kwargs['user_url']).exists():
raise Http404()
self.context = self.get_menu_context('profile', 'Профиль')
self.context['profile'] = Profile.objects.get(custom_url=kwargs['user_url'])
user_item = User.objects.get(profile=Profile.objects.get(custom_url=kwargs['user_url']))
self.context['c_user'] = user_item
post_image_form_set = modelformset_factory(
PostImages, form=PostImageForm, extra=10, max_num=10
)
pass_add_to_friends = False
is_blacklisted = False
if user_item != request.user:
pass_add_to_friends = self.is_in_friend_list(pass_add_to_friends, request, user_item)
is_blacklisted = self.is_in_blacklist(is_blacklisted, request, user_item)
self.context['is_in_blacklist'] = is_blacklisted
self.context['is_friend'] = True if request.user in user_item.profile.friends.all() \
and request.user != user_item else False
self.context['pass_add_to_friends'] = pass_add_to_friends
self.context['postform'] = PostForm()
self.context['formset'] = post_image_form_set(queryset=PostImages.objects.none())
if not is_blacklisted:
self.pagination_elements(
request,
list(reversed(user_item.profile.posts.all())),
self.context,
'c_user_posts'
)
self.context['action_type'] = reverse('profile-post-create')
return render(request, self.template_name, self.context)
def get_context(self, request):
self.post_instance = get_object_or_404(Post.objects_from_local_language, slug_title=self.kwargs.get("title"))
self.post_form = PostForm(instance=self.post_instance)
self.image_form = self.get_form(request, ImageForm, None)
self.content_form = self.get_form(request, ContentNewForm, None)
context = {"post_form": self.post_form, "content_form": self.content_form,
"image_form": self.image_form, "post_instance": self.post_instance}
return context
def post_new(request):
if request.method == "POST":
# save the post form
form = PostForm(request.POST)
if form.is_valid():
new_post = form.save(commit=False)
new_post.slug = slugify(unidecode(new_post.title))
new_post.author = request.user
new_post.status = 'published'
new_post.save()
return HttpResponseRedirect('/post')
else:
print("invalid form")
return render(request, 'post/new_post.html', {'form': form})
else:
# display the post form
form = PostForm()
return render(request, 'post/new_post.html', {'form': form})
