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 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 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)