class AddCommentView(TemplateView): @method_decorator(writeable_site_required) @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): commentable_id = self.args[0] self.commentable = get_object_or_404(self.commentable_model, id=commentable_id) self.comment = Comment(commentable=self.commentable, user=request.user) return super(AddCommentView, self).dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): self.form = CommentForm(instance=self.comment, prefix='comment') context = self.get_context_data() return self.render_to_response(context) def post(self, request, *args, **kwargs): self.form = CommentForm(request.POST, instance=self.comment, prefix='comment') if self.form.is_valid(): self.form.save() return redirect( self.commentable.get_absolute_url() + ('#comment-%d' % self.comment.id) ) else: context = self.get_context_data() return self.render_to_response(context) def get_context_data(self, **kwargs): context = super(AddCommentView, self).get_context_data(**kwargs) context['commentable'] = self.commentable context['commentable_name'] = self.get_commentable_name(self.commentable) context['comment_form'] = self.form context['submit_action'] = self.submit_action return context template_name = 'comments/add_comment.html'
def process_post_add_comment(request, context, datapackage, force_anonymous_user, success_view_name, failure_template_name): if force_anonymous_user: person = None else: person = Person.objects.get(user=request.user) comment_form = CommentForm(request.POST, datapackage_id=datapackage.id, person=person) if comment_form.is_valid(): comment_form.save() messages.success(request, 'Comment saved') return redirect( reverse(success_view_name, kwargs={'uuid': datapackage.uuid})) else: messages.error( request, 'Error saving the comment. Check below for the error messages') context['comment_form'] = comment_form return render(request, failure_template_name, context)
def get_context_data(self, *args, **kwargs): context = super(PostDetailView, self).get_context_data(*args, **kwargs) post_id = ( self.kwargs['year'], self.kwargs['month'], self.kwargs['day'], self.kwargs['slug'], ) try: obj = self.pseudo_model.get_object(post_id) except KeyError: raise Http404 context['obj'] = obj context['comments'] = Comment.objects.filter(url=obj.url) if self.request.method == 'POST': form = CommentForm(self.request.POST, obj=obj, request=self.request) if form.is_valid(): form.save() messages.success(self.request, 'Your comment has been posted.') else: form = CommentForm() context['form'] = form context['ONE_YEAR_TIMEOUT'] = ONE_YEAR_TIMEOUT return context
def detail(request, pk): post = get_object_or_404(Post, pk=pk) tags = Tag.objects.all() liked_posts = (Post.objects.all().annotate( likes_count=Count("like")).order_by("-likes_count")) categories = Category.objects.all() context = { "post": post, "categories": categories, "tags": tags, "liked_posts": liked_posts } if request.method == "POST": comment = request.POST.copy() comment['post'] = post.id if request.user: comment['user'] = request.user.id form = CommentForm(comment) if form.is_valid(): # some logic form.save() return redirect('blog:post_detail', pk) else: form = CommentForm() context['form'] = form return render(request, "core/detail.html", context)
class AddCommentView(TemplateView): @method_decorator(writeable_site_required) @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): commentable_id = self.args[0] self.commentable = get_object_or_404(self.commentable_model, id=commentable_id) self.comment = Comment(commentable=self.commentable, user=request.user) return super().dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): self.form = CommentForm(instance=self.comment, prefix='comment') context = self.get_context_data() return self.render_to_response(context) def post(self, request, *args, **kwargs): self.form = CommentForm(request.POST, instance=self.comment, prefix='comment') if self.form.is_valid(): self.form.save() return redirect( self.commentable.get_absolute_url() + ('#comment-%d' % self.comment.id) ) else: context = self.get_context_data() return self.render_to_response(context) def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context['commentable'] = self.commentable context['commentable_name'] = self.get_commentable_name(self.commentable) context['comment_form'] = self.form context['submit_action'] = self.submit_action return context template_name = 'comments/add_comment.html'
def create_comment(request, slug=None): try: instance = Post.objects.get(slug=slug) except ObjectDoesNotExist: instance = None form = CommentForm(request.POST or None) print('The form data :', form) if form.is_valid(): print(form.cleaned_data) form_data = form.save(commit=False) form_data.user = request.user form_data.content_type = instance.get_content_type form_data.object_id = instance.id form_data.parent = None try: parent_id = int(request.POST.get('parent_id')) except: parent_id = None if parent_id: parent_qs = Comment.objects.filter(id=parent_id) if parent_qs.exists() and parent_qs.count() == 1: parent_obj = parent_qs.first() print('parent_obj :',parent_obj) form_data.parent = parent_obj form.save() messages.success(request, 'form has being submitted') return HttpResponseRedirect(instance.get_absolute_url()) else: messages.error(request, f'{form.errors}') return redirect('blog:blog_detail', instance.slug)
def process_post_add_comment(request, context, datapackage, force_anonymous_user, success_view_name, failure_template_name): if force_anonymous_user: logged_user = None else: logged_user = request.user comment_form = CommentForm(request.POST, datapackage_id=datapackage.id, logged_user=logged_user, allow_private=True) if comment_form.is_valid(): comment_form.save() messages.success(request, 'Comment saved') return redirect( reverse(success_view_name, kwargs={'uuid': datapackage.uuid})) else: messages.error( request, 'Error saving the comment. Check below for the error messages') context['comment_form'] = comment_form context['datapackage'] = datapackage return render(request, failure_template_name, context)
def comment_new(request): if request.method == 'POST': id = request.POST['user_id'] #subject = request.POST['title'] user = request.POST['username'] # last_name = request.POST['last_name'] #lastname = request.POST['lastname'] print('ITEMS') for key, value in request.POST.items(): print(str(key) + "--") print(str(value)) form = CommentForm(request.POST, request.FILES) # print formset.errors if form.is_valid(): form.save() # send_mail("[ENGLISH] " + subject,user +" "+ last_name + " said "+ message + " on http://english.darwoft.com:8000", '*****@*****.**', # ['*****@*****.**'], fail_silently=False) posts = Post.objects.all().order_by('-created') return render(request, os.path.join(BASE_DIR, 'templates', 'posts', 'feed.html'), {'posts': posts})
def detail(request, blog_id): post = get_object_or_404(Post, pk=blog_id) if request.method == 'POST' and request.user.is_authenticated: comment_form = CommentForm(request.POST, request.FILES) if comment_form.is_valid(): comment_instance = comment_form.save(commit=False) comment_instance.comment_user = request.user comment_instance.content_type = ContentType.objects.get_for_model(Post) comment_instance.content_object = post comment_instance.object_id = post.id parent_id = request.POST.get('parent_id') if parent_id is not None: comment_instance.parent_comment = Comment.objects.get(pk=int(parent_id)) comment_form.save() comment_form.save_m2m() return HttpResponseRedirect(post.get_absolute_url()) post_comments = post.blog_comment.filter(parent_comment=None).order_by('-comment_date_time') page_post_comments = page_list(request, post_comments, 10) context = { 'booklog': post.content_object, 'post': post, 'post_comments': page_post_comments, 'comment_form': CommentForm(), } return render(request, 'blog/detail.html', context)
def ticket_detail(request, pk): ticket = get_object_or_404(Ticket, pk=pk) user = request.user comments = Comment.objects.filter(ticket=ticket) if request.method == 'POST': if user.is_authenticated: comment_form = CommentForm(request.POST) if comment_form.is_valid(): comment_form.instance.user = user comment_form.instance.ticket = ticket comment_form.save() return redirect('ticket-detail', pk) else: comment_form = CommentForm() else: messages.error(request, 'Please login to comment') comment_form = CommentForm() else: comment_form = CommentForm() return render( request, 'main/ticket_detail.html', { "object": ticket, "pk": pk, "comments": comments, 'comment_form': comment_form })
def edit_comment(request, comment_id): if not request.user.is_authenticated(): return request_login(request) try: comment = Comment.objects.get(id=comment_id) except: raise Http404 if not request.user == comment.user: messages.add_message(request, messages.ERROR, "You can only edit your own comments.") return HttpResponseRedirect(reverse('proposal', args=[ str(comment.proposal.id), comment.proposal.slug ])) else: if request.method == "POST": if comment.is_new(): form = CommentForm(request.POST, instance=comment) if form.is_valid(): form.save() messages.add_message(request, messages.SUCCESS, "Comment edited.") return HttpResponseRedirect(reverse("proposal", args=[ str(comment.proposal.id), comment.proposal.slug ]) + "#comment_" + str(comment.id)) else: messages.add_message(request, messages.ERROR, "Invalid comment") else: messages.add_message(request, messages.ERROR, "You can only edit a comment in the " "first 5 minutes.") form = CommentForm(instance=comment) if comment.is_new(): if request.is_ajax(): extend_template = "ajax_base.html" else: extend_template = "base.html" return render(request, "edit_comment_form.html", {"form": form, "comment": comment, "extend_template": extend_template}) else: messages.add_message(request, messages.ERROR, "You can only edit a comment in the " "first 5 minutes.") return HttpResponseRedirect(reverse("proposal", args=[ str(comment.proposal.id), comment.proposal.slug ]) + "#comment_" + str(comment.id))
def update(request, pk): comment = get_object_or_404(Comment, pk=pk) if request.method == "POST": form = CommentForm(request.POST, instance=comment) if form.is_valid(): form.save() return HttpResponseRedirect("%s#%s" % ( comment.link.get_absolute_url(), comment.id)) else: print form.errors
def add_comment(request, article_id): if request.POST and ("pause", not request.session): form = CommentForm(request.POST) return_path = request.META.get('HTTP_REFERER', '/') if form.is_valid(): comment = form.save(commit=False) comment.comment_user = request.user comment.comment_article = Article.objects.get(id=article_id) form.save() request.session.set_expiry(600) request.session['pause'] = True return redirect(return_path)
def add_comment(request, article_id): if request.POST and ("pause", not request.session): form = CommentForm(request.POST) return_path = request.META.get('HTTP_REFERER', '/') if form.is_valid(): comment = form.save(commit=False) comment.comment_user = request.user comment.comment_article = Article.objects.get(id = article_id) form.save() request.session.set_expiry(600) request.session['pause'] = True return redirect(return_path)
def post_detail(request, year, month, day, slug): post = get_object_or_404(Post, slug=slug, status='published', published__year=year, published__month=month, published__day=day) categories = post.category.all() comments = post.comments.filter(parent__isnull=True).order_by('-created') if request.method == 'POST': comment_form = CommentForm(request.POST) if comment_form.is_valid(): parent_obj = None try: parent_id = int(request.POST.get('parent_id')) except: parent_id = None if parent_id: parent_obj = PostComment.objects.get(id=parent_id) if parent_obj: replay_comment = comment_form.save(commit=False) replay_comment.parent = parent_obj new_comment = comment_form.save(commit=False) new_comment.post = post new_comment.save() return redirect(request.path) else: comment_form = CommentForm() try: previous_post = post.get_previous_by_published() except post.DoesNotExist: previous_post = post try: next_post = post.get_next_by_published() except post.DoesNotExist: next_post = post return render( request, 'posts/post_detail.html', { 'post': post, 'categories': categories, 'comment_form': comment_form, 'comments': comments, 'previous_post': previous_post, 'next_post': next_post })
def create_comment(request): """Create comment view.""" if request.method == 'POST': form = CommentForm(None, data=request.POST) if form.is_valid(): with transaction.atomic(): comment = form.save(commit=False) comment.user = request.user comment.content = json.loads(form.cleaned_data.get('content'))[ 'html'] # Quill form field's html form.save() create_notification(request, form) run_reputation_update(request.user) return redirect('post', pk=request.POST['post'])
def addcomment(request, talent_id): if request.POST and ("pause" not in request.session): # sozdaem formu-->raznosim v nee dannie is post zaprosa form = CommentForm(request.POST) # esli forma validna if form.is_valid(): # zapret auti sohraneniya formi comment = form.save(commit=False) # nahodim, k kakomu talantu sohranit' comment.comments_talent = Talent.objects.get(id=talent_id) comment.comments_from = request.user form.save() # request.session.set_expiry(60) # request.session['pause'] = True return redirect('/talents/get/%s/' % talent_id)
class EditCommentView(TemplateView): @method_decorator(writeable_site_required) @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): commentable_id = self.args[0] comment_id = self.args[1] commentable_type = ContentType.objects.get_for_model( self.commentable_model) self.commentable = get_object_or_404(self.commentable_model, id=commentable_id) self.comment = get_object_or_404(Comment, id=comment_id, content_type=commentable_type, object_id=commentable_id) if not request.user.is_staff: return redirect(self.comment.get_absolute_url()) return super(EditCommentView, self).dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): self.form = CommentForm(instance=self.comment, prefix='comment') context = self.get_context_data() return self.render_to_response(context) def post(self, request, *args, **kwargs): self.form = CommentForm(request.POST, instance=self.comment, prefix='comment') if self.form.is_valid(): self.form.save() return redirect(self.comment.get_absolute_url()) else: context = self.get_context_data() return self.render_to_response(context) def get_context_data(self, **kwargs): context = super(EditCommentView, self).get_context_data(**kwargs) context['commentable'] = self.commentable context['commentable_name'] = self.get_commentable_name( self.commentable) context['comment'] = self.comment context['comment_form'] = self.form context['submit_action'] = self.submit_action return context template_name = 'comments/edit_comment.html'
def blog(request, slug): from comments.models import BLOG blog = Blog.objects.get(slug=slug) if not blog: raise Http404 form = CommentForm() if request.POST: form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.user comment.thing_id = blog.id comment.type = BLOG comment.thread_id, comment.reverse_thread_id = \ get_thread_id(type='blog', thing_id=blog.id) comment.save() return HttpResponseRedirect(reverse( 'blog.views.blog', args=(blog.slug,))) commentsPage, commentsIndex, commentsTree = \ get_comments_page(request, type=BLOG, obj=blog, rpp=10) return render_to_response(request, 'blog/blog.html', { 'blog': blog, 'commentForm': form, 'comments': commentsPage, 'commentsIndex': commentsIndex, 'commentsTree': commentsTree, })
def detail(request, pk): post = get_object_or_404(Post, pk=pk) if post.draft: if post.user != request.user: messages.error(request,'you have not permission to see that post',extra_tags='alert alert-danger') return redirect('posts:index') form=CommentForm(request.POST or None) # add comment if form.is_valid() and request.user.is_authenticated: instance=form.save(commit=False) instance.user=request.user instance.post=post parent=None try: parent_id=int(request.POST.get('parent_id')) except: parent_id=None if parent_id: query=Comment.objects.filter(id=parent_id) if query.exists(): parent=query.first() instance.parent=parent instance.save() return redirect('posts:detail',pk) return render(request, 'detail.html', {'post': post,'comment_form':form})
class NewsDetail(DetailView): model = Article template_name = 'news/article.html' @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): self.comment_form = CommentForm(request.POST or None) # create filled (POST) or empty form (initial GET) if request.method == 'POST': self.comment_form.instance.article_id = self.get_object().id if self.comment_form.is_valid(): comment = self.comment_form.save(commit=True) client = Client() client.publish(self.get_object().get_cent_comments_channel_name(), comment.as_compact_dict()) cent_response = client.send() print('sent to channel {}, got response from centrifugo: {}'.format(self.get_object().get_cent_comments_channel_name(), cent_response)) return HttpResponse() # return HttpResponseRedirect(reverse('news:detail', args=[self.get_object().pk,])) else: return super().get(request, *args, **kwargs) # context = self.get_context_data() # return render('news/article.html', context) return super().dispatch(request, *args, **kwargs) def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context['comment_form'] = self.comment_form return context
def post_show(request, blog, slug): try: blog = Blog.objects.get(slug=blog) except: raise Http404(u'Não disponível') try: post = Post.published.get(slug=slug, blog=blog) except: raise Http404(u'Não disponível') if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.submit_date = datetime.now() comment.user = None comment.site = Site.objects.get_current() comment.ip_address = request.META.get("REMOTE_ADDR", None) comment.content_type = ContentType.objects.get_for_model(post) comment.object_pk = post.id comment.save() return HttpResponseRedirect(reverse('post_show',args=(blog.slug,post.slug))) else: form = CommentForm() return render_to_response('blog/post_show.html', { 'post': post, 'blog': blog, 'form':form, }, context_instance=RequestContext(request))
def post(self, request, pk): self.object = get_object_or_404(Article, id=pk) comment = CommentForm(request.POST) commit_instance = comment.save() self.object.comments.add(commit_instance) self.object.save() return redirect(reverse('article_detail', args=[pk]))
def edit_comment(request, problem_id, solution_id, comment_id): solution = Solution.objects.get(pk=solution_id) try: comment = Comment.objects.get(pk=comment_id) if comment.user.email != request.session['email']: return HttpResponseRedirect('/problems/'+str(problem_id)+'/show_solution/'+str(solution_id)) except Comment.DoesNotExist: raise Http404("Comment does not exist") if request.method == 'POST': comment_form = CommentForm(request.POST, instance=comment) if comment_form.is_valid(): comment = comment_form.save(commit=False) comment.user = UserProfile.objects.get(email=request.session['email']) comment.save() solution.comments.add(comment) return HttpResponseRedirect('/problems/'+str(problem_id)+'/show_solution/'+str(solution_id)) else: print comment_form.errors elif request.method == 'GET': c_edit = comment # c_edit.content = bleach.clean(c_edit.content, strip=True) comment_form = CommentForm(instance=c_edit) return render(request, 'problems/edit_comment.html', {'form': comment_form, 'problem_id': problem_id, 'solution_id': solution_id, 'comment':comment})
def edit_comment(request, sub_id, comment_id): submission = Submission.objects.get(pk=sub_id) try: comment = Comment.objects.get(pk=comment_id) if comment.user.email != request.session['email']: return HttpResponseRedirect('/submissions/show/'+str(sub_id)) except Comment.DoesNotExist: raise Http404("Comment does not exist") if request.method == 'POST': comment_form = CommentForm(request.POST, instance=comment) if comment_form.is_valid(): comment = comment_form.save(commit=False) comment.user = UserProfile.objects.get(email=request.session['email']) # comment.content = bleach.clean(comment.content, strip=True) # comment.content = markdown.markdown(comment.content) comment.save() submission.comments.add(comment) return HttpResponseRedirect('/submissions/show/' + str(sub_id)) else: raise Http404("Form is not valid") elif request.method == 'GET': c_edit = comment # c_edit.content = bleach.clean(c_edit.content, strip=True) comment_form = CommentForm(instance=c_edit) return render(request, 'submissions/edit_comment.html', {'form': comment_form, 'sub_id': sub_id, 'comment':comment})
def article_show(request, channel, slug): try: article = Article.published_detail.get(slug=slug, channel__slug=channel) article.views_count_last_week += 1 article.views_count += 1 article.save() except: raise Http404(u'Notícia não encontrada') if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.submit_date = datetime.now() comment.user = None comment.site = Site.objects.get_current() comment.ip_address = request.META.get("REMOTE_ADDR", None) comment.content_type = ContentType.objects.get_for_model(article) comment.object_pk = article.id comment.save() return HttpResponseRedirect(reverse('article_show',args=(article.channel.slug,article.slug))) else: form = CommentForm() related_articles = article.get_related_articles() return render_to_response('articles/article_show.html', { 'article': article, 'related_articles': related_articles, 'form':form, 'is_article':True, }, context_instance=RequestContext(request))
def post_comment(request, post_pk): post = get_object_or_404(Post, pk=post_pk) # 判断用户的post请求,接收到时则处理表单数据 if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) # commit=False,暂不保存 comment.post = post comment.save() # 重定向到 post 的详情页,实际上当 redirect 函数接收一个模型的实例时,它会调用这个模型实例的 get_absolute_url 方法, # 然后重定向到 get_absolute_url 方法返回的 URL。 return redirect(post) else: comment_list = post.comment_set.all() context = { 'post': post, 'form': form, 'comment_list': comment_list } return render(request, 'blog/detail.html', context=context) # 不是 post 请求,说明用户没有提交数据,重定向到文章详情页。 return redirect(post)
def edit_comment(request, comment_id): comment = get_object_or_404(Comment, id=comment_id) if not request.me.is_moderator: if comment.author != request.me: raise AccessDenied() if not comment.is_editable: raise AccessDenied( title="Этот комментарий больше нельзя редактировать") if not comment.post.is_visible or not comment.post.is_commentable: raise AccessDenied(title="Комментарии к этому посту были закрыты") post = comment.post if request.method == "POST": form = CommentForm(request.POST, instance=comment) if form.is_valid(): comment = form.save(commit=False) comment.is_deleted = False comment.html = None # flush cache comment.ipaddress = parse_ip_address(request) comment.useragent = parse_useragent(request) comment.save() return redirect("show_comment", post.slug, comment.id) else: form = CommentForm(instance=comment) return render(request, "comments/edit.html", { "comment": comment, "post": post, "form": form })
def comment(request, post_pk): # 先获取被评论的文章,因为后面需要把评论和被评论的文章关联起来 post = get_object_or_404(Post, pk=post_pk) form = CommentForm(request.POST) if form.is_valid(): # commit=False 的作用是仅仅利用表单的数据生成 Comment 模型类的实例,但还不保存评论数据到数据库。 comment = form.save(commit=False) comment.post = post comment.save() messages.add_message(request, messages.SUCCESS, '评论发表成功!', extra_tags='success') return redirect(post) context = { 'post': post, 'form': form, } messages.add_message(request, messages.ERROR, '评论发表失败!请修改表单中的错误后重新提交。', extra_tags='danger') return render(request, 'comments/preview.html', context=context)
def comment(request, post_pk): # 先获取被评论的文章,因为后面需要把评论和被评论的文章关联起来。 # 这里我们使用了 django 提供的一个快捷函数 get_object_or_404, # 这个函数的作用是当获取的文章(Post)存在时,则获取;否则返回 404 页面给用户。 post = get_object_or_404(Post, pk=post_pk) # django 将用户提交的数据封装在 request.POST 中,这是一个类字典对象。 # 我们利用这些数据构造了 CommentForm 的实例,这样就生成了一个绑定了用户提交数据的表单。 form = CommentForm(request.POST) # 当调用 form.is_valid() 方法时,django 自动帮我们检查表单的数据是否符合格式要求。 if form.is_valid(): # 检查到数据是合法的,调用表单的 save 方法保存数据到数据库, # commit=False 的作用是仅仅利用表单的数据生成 Comment 模型类的实例,但还不保存评论数据到数据库。 comment = form.save(commit=False) # 将评论和被评论的文章关联起来。 comment.post = post # 最终将评论数据保存进数据库,调用模型实例的 save 方法 comment.save() messages.add_message(request, messages.SUCCESS, '评论发表成功!', extra_tags='success') # 重定向到 post 的详情页,实际上当 redirect 函数接收一个模型的实例时,它会调用这个模型实例的 get_absolute_url 方法, # 然后重定向到 get_absolute_url 方法返回的 URL。 return redirect(post) # 检查到数据不合法,我们渲染一个预览页面,用于展示表单的错误。 # 注意这里被评论的文章 post 也传给了模板,因为我们需要根据 post 来生成表单的提交地址。 context = { 'post': post, 'form': form, } messages.add_message(request, messages.ERROR, '评论发表失败!请修改表单中的错误后重新提交。', extra_tags='danger') return render(request, 'comments/preview.html', context=context)
def PostDetail(request, post_id): post = get_object_or_404(Post, id=post_id) user = request.user is_favorite = False comments = Comment.objects.filter(post=post).order_by('date') # checks to see if you've bookmarked the post and use flag for color change of button if request.user.is_authenticated: profile = Profile.objects.get(user=user) if profile.favorites.filter(id=post_id).exists( ): # using this boolean flag to identify if post is bookmarked is_favorite = True # adds comment section to post detail view if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.post = post comment.user = user comment.save() return HttpResponseRedirect(reverse('post_detail', args=[post_id])) else: form = CommentForm() template = loader.get_template('post_detail.html') context = { 'post': post, 'is_favorite': is_favorite, 'profile': profile, 'form': form, 'comments': comments, } return HttpResponse(template.render(context, request))
def post_comment(request, post_pk): # 获得该评论的文章 post = get_object_or_404(Post, pk=post_pk) print(post.tags) if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) # 将评论和文章关联起来 comment.post = post comment.save() # 当表单的数据合法时 重定向到post的详情页 # 当redirect 函数接收一个模型的实例时, 会调用这个模型实例的get_absolute_url方法 # 这个方法会返回一个url 然后重定向到这个url return redirect(post) else: # comment_list = post.comment_set.all() context = { 'post': post, 'form': form, 'comment_list': comment_list } print(post.tags) # 当表单数据不合法时, return render(request, 'blog/detail.html', context=context) return redirect(post)
def post(self, request, booklog_id): booklog = get_object_or_404(BookLog, pk=booklog_id) comment_form = CommentForm(request.POST, request.FILES) if comment_form.is_valid(): comment_instance = comment_form.save(commit=False) comment_instance.comment_user = request.user comment_instance.content_type = ContentType.objects.get_for_model(BookLog) comment_instance.content_object = booklog comment_instance.object_id = booklog.id parent_id = request.POST.get('parent_id') if parent_id is not None: comment_instance.parent_comment = Comment.objects.get(pk=int(parent_id)) comment_form.save() comment_form.save_m2m() return HttpResponseRedirect(booklog.get_absolute_url()) return self.get(request, booklog_id)
def post_comment(request,pk): post = get_object_or_404(Post,pk=pk) form = CommentForm() if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) #comment.post = post comment.post_id = pk comment.save() #数据有误,需保存form表单所写的数据 else: comment_list = post.comment_set.all() context = { 'post':post, 'form':form, 'comment_list':comment_list, } return render(request,'blog/detail.html',context=context) #return redirect(reverse('blog:post_detail',kwargs={'pk':pk})) return redirect(post)
def post_comment(request, post_pk): # 先获取被评论的文章,因为后面需要把评论和被评论的文章关联起来 # 这里我们使用了Django提供的一个快捷函数 get_object_or_404 页面给用户 # 这个函数的作用是当前获取的文章(post)存在时,则获取;否则返回404页面给用户 post = get_object_or_404(Post, pk=post_pk) # HTTP 请求有get和POST两种,一般用户通过表单提交数据都是通过post请求 if request.method == 'POST': # 用户提交的数据存在request.POST中,这是一个类字典对象 form = CommentForm(request.POST) if form.is_valid(): # 检查到数据是合法的,调用表单的 save 方法保存数据到数据库, # commit=False 的作用是仅仅利用表单的数据生成 Comment 模型类的实例,但还不保存评论数据到数据库。 comment = form.save(commit=False) # 将评论和被评论的文章关联起来。 comment.post = post # 最终将评论数据保存进数据库,调用模型实例的 save 方法 comment.save() # 重定向到 post 的详情页,实际上当 redirect 函数接收一个模型的实例时,它会调用这个模型实例的 get_absolute_url 方法, # 然后重定向到 get_absolute_url 方法返回的 URL。 return redirect(post) else: # 使用 post.comment_set.all() 反向查询全部评论。 comment_list = post.comment_set.all() return render(request,'detail.html', locals()) return redirect(post)
def add(request): data = {} user = request.user comment_form = CommentForm(data=request.POST) if not comment_form.is_valid(): data['message'] = 'Form not valid!' else: try: post_id = int(request.POST.get('post_id', None)) except(TypeError, ValueError, OverflowError): post_id = None data['message'] = 'Wrong post id' if post_id: try: post = Post.objects.get(id=post_id) except post.DoesNotExist: post = None data['message'] = 'Post doesn\'t exist' if post: # Create Comment object but don't save to database yet new_comment = comment_form.save(commit=False) # Assign the current post to the comment new_comment.post = post new_comment.user = user # Save the comment to the database new_comment.save() data['success'] = True return JsonResponse(data)
def video_show(request, slug): try: video = Video.objects.get(slug=slug) except: raise Http404(u'Vídeo não encontrado.') related_videos = video.get_related_videos() if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.submit_date = datetime.now() comment.user = None comment.site = Site.objects.get_current() comment.ip_address = request.META.get("REMOTE_ADDR", None) comment.content_type = ContentType.objects.get_for_model(video) comment.object_pk = video.id comment.save() return HttpResponseRedirect(reverse('video_show',args=[video.slug])) else: form = CommentForm() return render_to_response('videos/video_show.html', { 'video': video, 'related_videos':related_videos, 'form':form, }, context_instance=RequestContext(request))
def post_comment(request): redirect_to = request.POST.get('next', request.GET.get('next', '')) postId = request.POST['postId'] post = get_object_or_404(Post, pk=postId) if request.method == 'POST': comment_form = CommentForm(request.POST) if comment_form.is_valid(): comment = comment_form.save(commit=False) commenterId = request.user.pk commenter = get_object_or_404(User, pk=commenterId) comment.post = post comment.commenter = commenter comment.save() underId = request.POST['underId'] replyToId = request.POST['replyToId'] comment_ext_form = CommentExtensionForm(request.POST) if underId != '' and comment_ext_form.is_valid(): comment_ext = comment_ext_form.save(commit=False) comment_ext.comment = comment under = get_object_or_404(Comment, pk=underId) replyTo = get_object_or_404(Comment, pk=replyToId) comment_ext.under = under comment_ext.replyTo = replyTo comment_ext.save() return redirect(post)
def add_comment(request, object_type, id): skip = False if object_type == 'comicpage': object = get_object_or_404(ComicPage, pk=id) elif object_type == 'article': object = get_object_or_404(Article, pk=id) elif object_type == 'profile': object = get_object_or_404(Profile, pk=id) friend_status = get_relationship_status(object.user, request.user) if friend_status < 2 and object.user != request.user: skip = True elif object_type == 'tutorial': object = get_object_or_404(Tutorial, pk=id) elif object_type == 'episode': object = get_object_or_404(Episode, pk=id) elif object_type == 'video': object = get_object_or_404(Video, pk=id) if request.method == 'POST' and not skip: form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.user comment.save() object.comments.add(comment) comments = object.comments.filter(is_deleted=False) return render_to_response('comments/list.html', {'comments':comments}, context_instance=RequestContext(request))
def post_comment(request, post_pk): post = get_object_or_404(Post, pk=post_pk) if request.method == 'POST': # 提交的表单在request.POST里面 form = CommentForm(request.POST) if form.is_valid(): # 用表单数据生成Comment类的实例,不保存到数据库 # 因为只有form定义的字段 comment = form.save(commit=False) comment.post = post comment.save() return redirect(post) else: # 反向查找所有评论 comment_list = post.comment_set.all() context = { 'post': post, 'form': form, 'comment_list': comment_list } return render(request, 'dw_blog/detail.html', context=context) # 不是post请求, 没有提交数据 # 如果只返回模型实例,那么这个模型必须实现get_absolute_url方法 return redirect(post)
def new(request, pk): note = get_object_or_404(Note, pk=pk) if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.note = note comment.user = request.user comment.save() # add rep add_rep(request, c=comment) # create notification notify(comment=comment) d = { 'comment': comment, 'comment_form': CommentForm(), 'note': note, 'reply_form': ReplyForm(), 'static': settings.STATIC_URL, } comment_form = loader.get_template('comments/comment_form.html') comment_temp = loader.get_template('comments/comment.html') context = RequestContext(request, add_csrf(request, d)) data = { 'comment': comment_temp.render(context), 'comment_count': note.comment_count(), 'comment_form': comment_form.render(context), 'comment_pk': comment.pk, 'note_pk': note.pk, } return HttpResponse(json.dumps(data), mimetype='application/json') return HttpResponseRedirect(reverse('readings.views.detail', args=[reading.slug]))
def post_comment(request, post_pk): # 先获取评论的文章,后面把评论和被评论的文章关联起来 # 使用Django提供的get_object_404 # 这个函数的作用是当文章存在是获取 不存在时返回404给用户 post = get_object_or_404(Post, pk=post_pk) # HTTP 请求有get和post 两种 一般用户是通过表单提交数据都是post请求 # 因此只有当客户的请求是post的时候才需要处理 if request.method == 'POST': # 用户提交的数据存在request.POST中 这是一个字典对象 # 我们利用这些数据构造了commentform的实例这样的话Django的表单就成了 # 当调用form_is_vaild()方法时,Django会自动的帮我们检查表单的数据是否符合格式的需求 form = CommentForm(request.POST) if form.is_valid(): # 检查是否是合法的 调用表单的save()方法保存到数据库 # commit = False 的作用是仅仅利用,表单的数据生成comment实例,但不保存到评论数据到数据库 comment = form.save(commit=False) # 将评论和被评论的文章连接起来 comment.post = post # 将最终的评论数保存到数据库,调用模型实例的save()方法 comment.save() # 从新定向到 详情页 return redirect(post) else: comment_list = post.comment_set.all() context = { "post": post, "form": form, "comment_list": comment_list, } return render(request, "blog/detail.html", context=context) return redirect(post)
def post_comment(request, post_pk): # 这个函数的作用是当获取的文章(Post)存在时,则获取;否则返回 404 页面给用户。 post = get_object_or_404(Post, pk=post_pk) if request.method == 'POST': # 用户提交的数据存在 request.POST 中,这是一个类字典对象。 form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) # 将评论和被评论的文章关联起来 comment.post = post comment.save() # 重定向到 post 的详情页,实际上当 redirect 函数接收一个模型的实例时,它会调用这个模型实例的 get_absolute_url 方法, # 然后重定向到 get_absolute_url 方法返回的 URL。 return redirect(post) else: # 检查到数据不合法,重新渲染详情页,并且渲染表单的错误。 # 因此我们传了三个模板变量给 detail.html, # 一个是文章(Post),一个是评论列表,一个是表单 form # 注意这里我们用到了 post.comment_set.all() 方法, # 这个用法有点类似于 Post.objects.all() # 其作用是获取这篇 post下的的全部评论, # 因为 Post 和 Comment 是 ForeignKey 关联的, # 因此使用 post.comment_set.all() 反向查询全部评论。 comment_list = post.comment_set.all() context = {'post': post, 'form': form, 'comment_list': comment_list } return render(request, 'blog/detail.html', context=context) # 不是 post 请求,说明用户没有提交数据,重定向到文章详情页。 return redirect(post)
def post_detail(request, year, month, day, post): post = get_object_or_404(Post, slug=post, status='published', publish__year=year, publish__month=month, publish__day=day) similiar_posts = post.get_similiar_posts() comments = post.comments.filter(active=True) if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): new_comment = form.save(commit=False) new_comment.post = post new_comment.save() else: form = CommentForm() context = { 'post': post, 'comments': comments, 'form': form, 'similiar_posts': similiar_posts } return render(request, 'blog/post/detail.html', context)
def post_detail(request, pk=None): post = get_object_or_404(Post, pk=pk) comment_form = CommentForm() is_liked = False if post.likes.filter(id=request.user.id).exists(): is_liked = True if request.user.is_authenticated: if request.method == 'POST': # A comment was posted comment_form = CommentForm(data=request.POST) if comment_form.is_valid(): # Create Comment object but don't save to database yet new_comment = comment_form.save(commit=False) # Assign the current post to the comment new_comment.user = request.user new_comment.post = post # Save the comment to the database new_comment.save() context = { 'post': post, 'is_liked': is_liked, 'comment_form': comment_form } return render(request, 'posts/post_detail.html', context)
def album_details(request, pk): '''shows the photos, comments, ratings of an album''' album = get_object_or_404(Album, pk=pk) # if logged in user is not the album publisher then shows 404 page. if not request.user == album.user: raise Http404 photos = album.photos.all() comments = album.comments.all() if request.method == 'POST': comment_form = CommentForm(request.POST) if comment_form.is_valid(): comment = comment_form.save(commit=False) # assigns the Comment to the requested album. comment.album = album comment.save() return redirect('album:album_details', pk=album.pk) else: comment_form = CommentForm() context = { 'album': album, 'photos': photos, 'comment_form': comment_form, 'comments': comments } return render(request, "album/album_details.html", context)
def post(self, request, *args, **kwargs): form = CommentForm(request.POST) comment = form.save(commit=False) comment.resource = Resource.objects.filter( id=request.POST.get('resource_id')).first() comment.author = self.request.user comment.save() return HttpResponse("success", content_type='text/plain')
class EditCommentView(TemplateView): @method_decorator(writeable_site_required) @method_decorator(login_required) def dispatch(self, request, *args, **kwargs): commentable_id = self.args[0] comment_id = self.args[1] commentable_type = ContentType.objects.get_for_model(self.commentable_model) self.commentable = get_object_or_404(self.commentable_model, id=commentable_id) self.comment = get_object_or_404(Comment, id=comment_id, content_type=commentable_type, object_id=commentable_id) if not request.user.is_staff: return redirect(self.comment.get_absolute_url()) return super(EditCommentView, self).dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): self.form = CommentForm(instance=self.comment, prefix='comment') context = self.get_context_data() return self.render_to_response(context) def post(self, request, *args, **kwargs): self.form = CommentForm(request.POST, instance=self.comment, prefix='comment') if self.form.is_valid(): self.form.save() return redirect(self.comment.get_absolute_url()) else: context = self.get_context_data() return self.render_to_response(context) def get_context_data(self, **kwargs): context = super(EditCommentView, self).get_context_data(**kwargs) context['commentable'] = self.commentable context['commentable_name'] = self.get_commentable_name(self.commentable) context['comment'] = self.comment context['comment_form'] = self.form context['submit_action'] = self.submit_action return context template_name = 'comments/edit_comment.html'
def details(request, post_id): message = '' try: post = Post.objects.get(pk=post_id) if request.method == 'POST': data = request.POST.copy() form = CommentForm(data) if form.is_valid(): # save form.save() return HttpResponseRedirect('/posts/index') else: errors = form.errors else: form = CommentForm() data = {} except Post.DoesNotExist, e: message = str(e) post = None
def comment_reply(request, type, parent_id): parent_comment = Comment.objects.get(id=parent_id) response = {} if not parent_comment: response['error'] = 'Parent comment not found' if request.POST: form = CommentForm(request.POST) if form.is_valid(): comment = CommentForm(request.POST).save(commit=False) comment.thread_id, comment.reverse_thread_id = \ get_thread_id(type, parent_comment.thing_id, parent_comment) comment.author = request.user comment.thing_id = parent_comment.thing_id comment.type = type comment.parent_id = parent_comment.id comment.save() response['content'] = Markup.unescape( Markup( render_to_string(request, 'comments/comment.html', {'comment': comment}) ) ) return render_to_remote_response(request, json_context=response)
def comment_submit(request, post_slug): if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.user post = Post.objects.get(slug=post_slug) comment.post = post comment.save() comment_url = request.GET.get('next', '/')# +"#id-"+str(comment.id) return HttpResponseRedirect(comment_url) else: comment_url = request.GET.get('next', '/') return HttpResponseRedirect(comment_url)
def reply_submit(request, comment_id): if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.user comment.parent = Comment.objects.get(id=comment_id) comment.post = comment.parent.post comment.save() comment_url = request.GET.get('next', '/')+"#id-"+str(comment.id) return HttpResponseRedirect(comment_url) else: comment_url = request.GET.get('next', '/') return HttpResponseRedirect(comment_url)
def comment_submit(request, comment_id): if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.user comment.parent = Comment.objects.get(id=comment_id) comment.post = comment.parent.post comment.save() comment_url = request.GET.get('next', '/')+"#id-"+str(comment.id) return HttpResponseRedirect(comment_url) else: # return HttpResponse("string") return render(request, 'posts/create.html', { 'form':form, })
def post_comment(request): """ Handles comment submissions """ form = CommentForm(request.POST, auto_id="%s", prefix="CommentForm") if form.is_valid(): comment = form.save(commit=False) comment.ip_address = request.META.get("REMOTE_ADDR", None) comment.save() if request.is_ajax(): response = simple.direct_to_template(request, "comments/form.json", { "comment": comment, "total": Comment.objects.get_for_model(comment.obj).count(), }, mimetype="application/json") else: response = HttpResponseRedirect(comment.get_absolute_url()) if form.cleaned_data.get("remember", False): response.set_cookie("comment_author", value=comment.author) response.set_cookie("comment_email", value=comment.email) else: response.delete_cookie("comment_author") response.delete_cookie("comment_email") return response else: if request.is_ajax(): if form.errors: errors = simplejson.dumps(form.errors, cls=LazyEncoder, ensure_ascii=False) else: errors = None template = "comments/form.json" mimetype = "application/json" else: errors = None template = "comments/form.html" mimetype = None return simple.direct_to_template(request, template, { "form": form, "errors": errors, "total": 0, }, mimetype=mimetype)
def submit(request): if request.method == "POST": form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.posted_by = request.user comment.save() return HttpResponseRedirect("%s#%s" % ( comment.link.get_absolute_url(), comment.id)) else: print form.errors link_id = request.POST.get("link", False) if link_id: link = Link.objects.get(id=link_id) return HttpResponseRedirect(link.get_absolute_url()) #---------- return HttpResponseRedirect("/")
def save_comment(request): form = CommentForm(request.POST) comment = form.save(commit=False) comment.ip = request.META.get("REMOTE_ADDR", "") comment.created = datetime.today() comment.status = 0 comment.save() if request.POST.get("ret"): ret = request.POST.get("ret") elif request.META.get("HTTP_REFERER"): ret = request.META.get("HTTP_REFERER") else: ret = "/" ret += "?err=1" return HttpResponseRedirect(ret)
def comment_edit(request, comment_id): comment = Comment.objects.get(id=comment_id) nextpage = request.GET.get("next", "/") if request.method == "POST": form = CommentForm(request.POST, instance=comment) if form.is_valid(): comment = form.save(commit=False) comment.save() return HttpResponseRedirect(nextpage) else: form = CommentForm(instance=comment) return render(request, "comments/comment-edit.html", {"comment": comment, "form": form, "nextpage": nextpage}) # throw him out if he's not an author if request.user != comment.author: return HttpResponseRedirect("/") return HttpResponseRedirect("/") # to story list
def comment_new(request): if request.method == "POST": print("at comment_new") form = CommentForm(data=request.POST) print(form.errors) if form.is_valid(): comment = form.save(commit=False) #comment.post=post comment.author = Author.objects.get(user=request.user.id) postid = request.POST.get("post_id", "") #print("post_id: %s"%postid) post = Post.objects.get(post_id=postid) #print("post: %s"%post) comment.post = post comment.pub_date = timezone.now() comment.save() return redirect('/profile') else: form = CommentForm() return render(request, 'authors/index.html', {'form': form})
def add_new_comment(request, solution_id, problem_id): solution = Solution.objects.get(pk=solution_id) problem = Problem.objects.get(pk=problem_id) if request.method == 'POST': comment_form = CommentForm(request.POST) if comment_form.is_valid(): comment = comment_form.save(commit=False) comment.content = bleach.clean(comment.content, strip=True) comment.user = UserProfile.objects.get(email=request.session['email']) comment.save() solution.comments.add(comment) else: raise Http404('Form is not valid') problem.description = markdown.markdown(problem.description, extensions=['markdown.extensions.fenced_code']) solution = Solution.objects.get(pk=solution_id) comments_list = [] for comment in solution.comments.order_by('-posted'): comment.content = markdown.markdown(comment.content, extensions=['markdown.extensions.fenced_code']) comments_list.append(comment) return HttpResponseRedirect('/problems/'+str(problem_id)+'/show_solution/'+str(solution_id))
def comment_submit(request, comment_id): if request.method == "POST": form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.user comment.parent = Comment.objects.get(id=comment_id) comment.post = comment.parent.post comment.save() # Send Email # send_comment_email_notification(comment) # if comment.parent.author.email_comments: # commentauthor = comment.author.username # topic = commentauthor + " has replied to your comment" # body = commentauthor + " has replied to your comment\n" +\ # "http://fictionhub.io"+comment.post.get_absolute_url()+ "\n" +\ # "'" + comment.body[:64] + "...'" # body += "\n\nYou can manage your email notifications in preferences:\n" +\ # "http://fictionhub.io/preferences/" # try: # email = comment.parent.author.email # send_mail(topic, body, '*****@*****.**', [email], fail_silently=False) # except: # pass # Notification message = Message( from_user=request.user, to_user=comment.parent.author, story=comment.post, comment=comment, message_type="reply", ) message.save() comment.parent.author.new_notifications = True comment.parent.author.save() comment_url = request.GET.get("next", "/") + "#id-" + str(comment.id) return HttpResponseRedirect(comment_url) else: # return HttpResponse("string") return render(request, "posts/create.html", {"form": form})