def comment(request, template="generic/comments.html"): """ Handle a ``ThreadedCommentForm`` submission and redirect back to its related object. """ response = initial_validation(request, "comment") if isinstance(response, HttpResponse): return response obj, post_data = response form = ThreadedCommentForm(request, obj, post_data) if form.is_valid(): url = obj.get_absolute_url() if is_spam(request, form, url): return redirect(url) comment = form.save(request) response = redirect(add_cache_bypass(comment.get_absolute_url())) # Store commenter's details in a cookie for 90 days. for field in ThreadedCommentForm.cookie_fields: cookie_name = ThreadedCommentForm.cookie_prefix + field cookie_value = post_data.get(field, "") set_cookie(response, cookie_name, cookie_value) return response elif request.is_ajax() and form.errors: return HttpResponse(dumps({"errors": form.errors})) # Show errors with stand-alone comment form. context = {"obj": obj, "posted_comment_form": form} response = render(request, template, context) return response
def comment(request, template="generic/comments.html"): """ Handle a ``ThreadedCommentForm`` submission and redirect back to its related object. """ try: model = get_model(*request.POST["content_type"].split(".", 1)) obj = model.objects.get(id=request.POST["object_pk"]) if request.method != "POST": raise ObjectDoesNotExist() except (KeyError, TypeError, AttributeError, ObjectDoesNotExist): # Something was missing from the post so abort. return HttpResponseRedirect("/") form = ThreadedCommentForm(request, obj, request.POST or None) if form.is_valid(): comment = form.get_comment_object() if request.user.is_authenticated(): comment.user = request.user comment.by_author = request.user == getattr(obj, "user", None) comment.ip_address = request.META.get("HTTP_X_FORWARDED_FOR", request.META["REMOTE_ADDR"]) comment.replied_to_id = request.POST.get("replied_to") comment.save() response = HttpResponseRedirect(comment.get_absolute_url()) # Store commenter's details in a cookie for 90 days. cookie_expires = 60 * 60 * 24 * 90 for field in ThreadedCommentForm.cookie_fields: cookie_name = ThreadedCommentForm.cookie_prefix + field cookie_value = request.POST.get(field, "") set_cookie(response, cookie_name, cookie_value, cookie_expires) return response else: # Show errors with stand-alone comment form. context = {"obj": obj, "posted_comment_form": form} return render(request, template, context)
def comment(request, template="generic/comments.html"): """ Handle a ``ThreadedCommentForm`` submission and redirect back to its related object. """ post_data = request.POST settings.use_editable() if settings.COMMENTS_ACCOUNT_REQUIRED: if not request.user.is_authenticated(): # Account required but user isn't authenticated - store # their post data in the session and redirect to login. request.session["unauthenticated_comment"] = post_data error(request, _("You must log in to comment. Please log in or " "sign up, and your comment will be posted.")) url = "%s?next=%s" % (settings.LOGIN_URL, reverse("comment")) return redirect(url) elif "unauthenticated_comment" in request.session: # User has logged in after post data being stored in the # session for an unauthenticated comment post, so use it. post_data = request.session.pop("unauthenticated_comment") try: model = get_model(*post_data["content_type"].split(".", 1)) obj = model.objects.get(id=post_data["object_pk"]) except (KeyError, TypeError, AttributeError, ObjectDoesNotExist): # Something was missing from the post so abort. return HttpResponseRedirect("/") form = ThreadedCommentForm(request, obj, post_data) if form.is_valid(): url = obj.get_absolute_url() if is_spam(request, form, url): return redirect(url) comment = form.get_comment_object() if request.user.is_authenticated(): comment.user = request.user comment.by_author = request.user == getattr(obj, "user", None) comment.ip_address = request.META.get("HTTP_X_FORWARDED_FOR", request.META["REMOTE_ADDR"]).split(',')[0].strip() comment.replied_to_id = post_data.get("replied_to") comment.save() comment_was_posted.send(sender=comment.__class__, comment=comment, request=request) url = add_cache_bypass(comment.get_absolute_url()) response = HttpResponseRedirect(url) # Store commenter's details in a cookie for 90 days. cookie_expires = 60 * 60 * 24 * 90 for field in ThreadedCommentForm.cookie_fields: cookie_name = ThreadedCommentForm.cookie_prefix + field cookie_value = post_data.get(field, "") set_cookie(response, cookie_name, cookie_value, cookie_expires) return response else: # Show errors with stand-alone comment form. context = {"obj": obj, "posted_comment_form": form} return render(request, template, context)
def comment(request, template="generic/comments.html"): """ Handle a ``ThreadedCommentForm`` submission and redirect back to its related object. """ post_data = request.POST settings.use_editable() if settings.COMMENTS_ACCOUNT_REQUIRED: if not request.user.is_authenticated(): # Account required but user isn't authenticated - store # their post data in the session and redirect to login. request.session["unauthenticated_comment"] = post_data error(request, _("You must log in to comment. Please log in or " "sign up, and your comment will be posted.")) url = "%s?next=%s" % (settings.LOGIN_URL, reverse("comment")) return redirect(url) elif "unauthenticated_comment" in request.session: # User has logged in after post data being stored in the # session for an unauthenticated comment post, so use it. post_data = request.session.pop("unauthenticated_comment") try: model = get_model(*post_data["content_type"].split(".", 1)) obj = model.objects.get(id=post_data["object_pk"]) except (KeyError, TypeError, AttributeError, ObjectDoesNotExist): # Something was missing from the post so abort. return HttpResponseRedirect("/") form = ThreadedCommentForm(request, obj, post_data) if form.is_valid(): url = obj.get_absolute_url() if is_spam(request, form, url): return redirect(url) comment = form.get_comment_object() if request.user.is_authenticated(): comment.user = request.user comment.by_author = request.user == getattr(obj, "user", None) comment.ip_address = request.META.get("HTTP_X_FORWARDED_FOR", request.META["REMOTE_ADDR"]) comment.replied_to_id = post_data.get("replied_to") comment.save() comment_was_posted.send(sender=comment.__class__, comment=comment, request=request) url = add_cache_bypass(comment.get_absolute_url()) response = HttpResponseRedirect(url) # Store commenter's details in a cookie for 90 days. cookie_expires = 60 * 60 * 24 * 90 for field in ThreadedCommentForm.cookie_fields: cookie_name = ThreadedCommentForm.cookie_prefix + field cookie_value = post_data.get(field, "") set_cookie(response, cookie_name, cookie_value, cookie_expires) return response else: # Show errors with stand-alone comment form. context = {"obj": obj, "posted_comment_form": form} return render(request, template, context)
def handle_comments(obj, request): """ A problem exists with having a single URL to handle posting generic data. If there's an error with the form, we have to either display the form with errors on a different page than the page where the form was originally rendered, or redirect back to the original page and lose the form errors. This function can be called from any view that contains comments. It returns a 3-item sequence containing two forms, one with posted data and one without, which are each used to build the threaded comment tree with forms for replying. The third item returned is a response object to redirect to if a comment is successfully posted. """ # Create two comment forms - one with posted data and errors that will be # matched to the form submitted via comment_id, and an empty one for all # other instances. cookie_prefix = "mezzanine-comment-" cookie_fields = ("user_name", "user_email", "user_url") initial = {} for field in cookie_fields: initial[field] = request.COOKIES.get(cookie_prefix + field, "") posted = request.POST or None posted_comment_form = ThreadedCommentForm(obj, posted, initial=initial) unposted_comment_form = ThreadedCommentForm(obj, initial=initial) response = None if request.method == "POST" and posted_comment_form.is_valid(): comment = posted_comment_form.get_comment_object() comment.by_author = request.user == getattr(obj, "user", None) comment.ip_address = request.META.get("HTTP_X_FORWARDED_FOR", request.META["REMOTE_ADDR"]) comment.replied_to_id = request.POST.get("replied_to") comment.save() #blog_post.comments.add(comment) response = HttpResponseRedirect(comment.get_absolute_url()) # Store commenter's details in a cookie for 90 days. cookie_expires = 60 * 60 * 24 * 90 for field in cookie_fields: cookie_name = cookie_prefix + field cookie_value = request.POST.get(field, "") set_cookie(response, cookie_name, cookie_value, cookie_expires) return posted_comment_form, unposted_comment_form, response
def comments_for(context, obj): """ Provides a generic context variable name for the object that comments are being rendered for. """ form = ThreadedCommentForm(context["request"], obj) try: context["posted_comment_form"] except KeyError: context["posted_comment_form"] = form context["unposted_comment_form"] = form context["comment_url"] = reverse("comment") context["object_for_comments"] = obj return context
def comment_on_review(request, template="generic/comments.html"): """ Handle a ``ThreadedCommentForm`` submission and redirect back to its related object. """ response = initial_validation(request, "comment_on_review") if isinstance(response, HttpResponse): return response obj, post_data = response form = ThreadedCommentForm(request, obj, request.POST) if form.is_valid(): url = obj.get_absolute_url() if is_spam(request, form, url): return redirect(url) comment = form.save(request) if request.is_ajax(): #comment = form.save(request) comments = [comment] html = render_to_string('generic/includes/subcomment.html', { 'comments_for_thread': comments }) res = {'html': html} return HttpResponse( simplejson.dumps(res), 'application/json' ) else: response = redirect(add_cache_bypass(comment.get_absolute_url())) return response elif request.is_ajax() and form.errors: return HttpResponse(dumps({"errors": form.errors})) # Show errors with stand-alone comment form. if not request.is_ajax(): context = {"obj": obj, "posted_comment_form": form} response = render(request, template, context) return response
def ajax_comments(request, pk): ''' Render to string the comments for a given BlogPost (or other object with comments). ''' # Returns either object matching pk or None obj = BlogPost.objects.filter(pk=pk).first() response_data = {} if not obj: response_data['success'] = 'false' else: context = {} context["request"] = request # First if `COMMENTS_ORDERBYSCORE` setting, we # need to call `order_comments_by_score_for` first. # This simulates how in a template we'd call # the `order_comments_by_score_for` tag before the # `comments_for` tag, setting the `all_comments` var # in the context in advance, so `comments_thread` tag doesn't # need to touch it. if settings.COMMENTS_ORDERBYSCORE: # Context passed by ref order_comments_by_score_for(context, obj) # Replicate context building of `comments_for` # (I should try and understand the posted/unposted distinction better.) context["object_for_comments"] = obj context["comment_url"] = reverse("comment") form = ThreadedCommentForm(context["request"], obj) try: context["posted_comment_form"] except KeyError: context["posted_comment_form"] = form context["unposted_comment_form"] = form # Now pretend we are `comments_for` tag, and get the string resp it would. comments_str = render_to_string("generic/includes/comments.html", RequestContext(request, context)) response_data = {} response_data['comments'] = comments_str response_data['success'] = 'true' return HttpResponse(json.dumps(response_data), content_type="application/json")
def comment(request, template="generic/comments.html"): """ Handle a ``ThreadedCommentForm`` submission and redirect back to its related object. """ post_data = request.POST settings.use_editable() if settings.COMMENTS_ACCOUNT_REQUIRED: if not request.user.is_authenticated(): # Account required but user isn't authenticated - store # their post data in the session and redirect to login. request.session["unauthenticated_comment"] = post_data error(request, _("You must log in to comment. Please log in or " "sign up, and your comment will be posted.")) url = "%s?next=%s" % (settings.LOGIN_URL, reverse("comment")) return redirect(url) elif "unauthenticated_comment" in request.session: # User has logged in after post data being stored in the # session for an unauthenticated comment post, so use it. post_data = request.session.pop("unauthenticated_comment") try: model = get_model(*post_data["content_type"].split(".", 1)) obj = model.objects.get(id=post_data["object_pk"]) except (KeyError, TypeError, AttributeError, ObjectDoesNotExist): # Something was missing from the post so abort. return HttpResponseRedirect("/") form = ThreadedCommentForm(request, obj, post_data) if form.is_valid(): url = obj.get_absolute_url() if is_spam(request, form, url): return redirect(url) comment = form.get_comment_object() if request.user.is_authenticated(): comment.user = request.user comment.by_author = request.user == getattr(obj, "user", None) comment.ip_address = request.META.get("HTTP_X_FORWARDED_FOR", request.META["REMOTE_ADDR"]) comment.replied_to_id = post_data.get("replied_to") comment.save() comment_was_posted.send(sender=comment.__class__, comment=comment, request=request) # Send notification emails. comment_url = add_cache_bypass(comment.get_absolute_url()) #======================================================================= # send email to reply or post people,instead of ADMINS #======================================================================= try: from mezzanine.blog.models import BlogPost notify_emails = [BlogPost.objects.get(id=comment.object_pk).user.email] if comment.threadedcomment.replied_to != None: other_email = comment.threadedcomment.replied_to.user_email notify_emails += [other_email] # print notify_emails except: notify_emails = filter(None, [addr.strip() for addr in settings.COMMENTS_NOTIFICATION_EMAILS.split(",")]) if notify_emails: subject = _("New comment for: ") + unicode(obj) context = { "comment": comment, "comment_url": comment_url, "request": request, "obj": obj, } send_mail_template(subject, "email/comment_notification", settings.DEFAULT_FROM_EMAIL, notify_emails, context, fail_silently=settings.DEBUG) response = HttpResponseRedirect(comment_url) # Store commenter's details in a cookie for 90 days. cookie_expires = 60 * 60 * 24 * 90 for field in ThreadedCommentForm.cookie_fields: cookie_name = ThreadedCommentForm.cookie_prefix + field cookie_value = post_data.get(field, "") set_cookie(response, cookie_name, cookie_value, cookie_expires) return response else: # Show errors with stand-alone comment form. context = {"obj": obj, "posted_comment_form": form} return render(request, template, context)