def save(self, request): """ Saves a new comment and sends any notification emails. """ comment = self.get_comment_object() obj = comment.content_object if request.user.is_authenticated(): comment.user = request.user comment.by_author = request.user == getattr(obj, "user", None) comment.ip_address = ip_for_request(request) comment.replied_to_id = self.data.get("replied_to") comment.save() comment_was_posted.send(sender=comment.__class__, comment=comment, request=request) notify_emails = split_addresses(settings.COMMENTS_NOTIFICATION_EMAILS) if notify_emails: subject = ugettext("New comment for: ") + str(obj) context = { "comment": comment, "comment_url": add_cache_bypass(comment.get_absolute_url()), "request": request, "obj": obj, } send_mail_template(subject, "email/comment_notification", settings.DEFAULT_FROM_EMAIL, notify_emails, context) return comment
def save(self, request): """ Saves a new comment and sends any notification emails. """ comment = self.get_comment_object() obj = comment.content_object if request.user.is_authenticated(): comment.user = request.user comment.by_author = request.user == getattr(obj, "user", None) comment.ip_address = ip_for_request(request) comment.replied_to_id = self.data.get("replied_to") comment.save() comment_was_posted.send(sender=comment.__class__, comment=comment, request=request) notify_emails = split_addresses(settings.COMMENTS_NOTIFICATION_EMAILS) if notify_emails: subject = _("New comment for: ") + str(obj) context = { "comment": comment, "comment_url": add_cache_bypass(comment.get_absolute_url()), "request": request, "obj": obj, } send_mail_template(subject, "email/comment_notification", settings.DEFAULT_FROM_EMAIL, notify_emails, context) return comment
def test_comment_email_sending_3(self): """ After the editor and coordinator post a comment, an additional coordinator posts a comment. One email is sent to the first coordinator, and a distinct email is sent to the editor. """ app, request = self._set_up_email_test_objects() self.assertEqual(len(mail.outbox), 0) _ = self._create_comment(app, self.coordinator1) _ = self._create_comment(app, self.editor) comment3 = self._create_comment(app, self.coordinator2) comment_was_posted.send( sender=Comment, comment=comment3, request=request ) self.assertEqual(len(mail.outbox), 2) # Either order of email sending is fine. try: self.assertEqual(mail.outbox[0].to, [self.coordinator1.email]) self.assertEqual(mail.outbox[1].to, [self.editor.email]) except AssertionError: self.assertEqual(mail.outbox[1].to, [self.coordinator1.email]) self.assertEqual(mail.outbox[0].to, [self.editor.email])
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 create_comment(obj, ct, **kwargs): defaults = { 'comment': '', 'content_type': ct, 'object_pk': obj.pk, 'site': Site.objects.get_current(), } defaults.update(kwargs) c = ThreadedComment.objects.create(**defaults) comment_was_posted.send(c.__class__, comment=c, request=None) return c
def create_legacy_comment(obj, **kwargs): defaults = { 'comment': '', 'content_type': ContentType.objects.get_for_model(obj), 'object_pk': obj.pk, 'site': Site.objects.get_current(), } defaults.update(kwargs) c = ThreadedComment.objects.create(**defaults) comment_was_posted.send(c.__class__, comment=c, request=None) return c
def create_legacy_comment(obj, **kwargs): defaults = { "comment": "", "content_type": ContentType.objects.get_for_model(obj), "object_pk": obj.pk, "site": Site.objects.get_current(), } defaults.update(kwargs) c = ThreadedComment.objects.create(**defaults) comment_was_posted.send(c.__class__, comment=c, request=None) return c
def save_comment(self, object): if 'add_comment' in self.cleaned_data and len(self.cleaned_data['add_comment']) > 0: # Add a comment for this task for this user. comment = Comment.objects.create(user=self.request.user, content_object=object, comment=self.cleaned_data['add_comment'], submit_date=timezone.now(), site_id=settings.SITE_ID, is_public=True, ip_address=self.request.META.get("REMOTE_ADDR", None), is_removed=False) comment_was_posted.send( sender=comment.__class__, comment=comment, request=self.request )
def save_comment(self, object): if 'add_comment' in self.cleaned_data and len( self.cleaned_data['add_comment']) > 0: # Add a comment for this task for this user. comment = Comment.objects.create( user=self.request.user, content_object=object, comment=self.cleaned_data['add_comment'], submit_date=timezone.now(), site_id=settings.SITE_ID, is_public=True, ip_address=self.request.META.get("REMOTE_ADDR", None), is_removed=False) comment_was_posted.send(sender=comment.__class__, comment=comment, request=self.request)
def save_comment_for(self, content_object): cleaned_data = self.cleaned_data user = self.request.user comment = Comment.objects.create( user=user if user.is_authenticated() else None, user_name=cleaned_data['name'], user_email=cleaned_data['email'], user_url=cleaned_data['url'], comment=cleaned_data['comment'], ip_address=self.ip_address, content_object=content_object, site=Site.objects.get_current()) comment_was_posted.send( sender=self.__class__, comment=comment, request=self.request) return comment
def test_comment_email_sending_1(self): """ A coordinator posts a comment to an Editor's application and an email is send to that Editor. An email is not sent to the coordinator. """ app, request = self._set_up_email_test_objects() self.assertEqual(len(mail.outbox), 0) comment1 = self._create_comment(app, self.coordinator1) comment_was_posted.send( sender=Comment, comment=comment1, request=request ) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, [self.editor.email])
def test_comment_email_sending_2(self): """ After a coordinator posts a comment, the Editor posts an additional comment. An email is sent to the coordinator who posted the earlier comment. An email is not sent to the editor. """ app, request = self._set_up_email_test_objects() self.assertEqual(len(mail.outbox), 0) _ = self._create_comment(app, self.coordinator1) comment2 = self._create_comment(app, self.editor) comment_was_posted.send( sender=Comment, comment=comment2, request=request ) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, [self.coordinator1.email])
# </Twig> # <Twig> comment = form.comment # </Twig> # Save the comment and signal that it was saved form.pre_save(request, comment) comment.save() form.post_save(request, comment) # Legacy signal comment_was_posted.send( sender = comment.__class__, comment = comment, request = request, ) # Redirect back to the original page + #comment_'comment.pk' redirect_url = Url(form.cleaned_data['from_url']) redirect_url.fragment = "c%s" % comment.pk # The name of this comment fragment is poo, but I'm sure people are using it already so no changing return HttpResponseRedirect(u"%s" % redirect_url) @login_required def mark_as_spam(request, comment_id): if not request.user.is_staff: return HttpResponseNotAllowed("You don't have sufficient access to mark this as spam.")
def save(self, request): """ Saves a new comment and sends any notification emails. """ post_data = request.POST review = self.get_comment_object() obj = review.content_object if request.user.is_authenticated(): review.user = request.user review.user_name = review.user.username review.by_author = request.user == getattr(obj, "user", None) review.ip_address = ip_for_request(request) review.replied_to_id = self.data.get("replied_to") requiredreviewrating_name = obj.get_requiredreviewratingfield_name() requiredreviewrating_manager = getattr(obj, requiredreviewrating_name) optionalreviewrating_name = obj.get_optionalreviewratingfield_name() optionalreviewrating_manager = getattr(obj, optionalreviewrating_name) if request.user.is_authenticated(): requiredreviewrating_instance = RequiredReviewRating(user=request.user) else: requiredreviewrating_instance = RequiredReviewRating() if request.user.is_authenticated(): optionalreviewrating_instance = OptionalReviewRating(user=request.user) else: optionalreviewrating_instance = OptionalReviewRating() if (post_data.get("title")): review.title = post_data.get("title") if (post_data.get("overall_value")): review.overall_value = post_data.get("overall_value") requiredreviewrating_instance.overall_value = review.overall_value if (post_data.get("price_value")): review.price_value = post_data.get("price_value") requiredreviewrating_instance.price_value = review.price_value if (post_data.get("website_ex_value")): review.website_ex_value = post_data.get("website_ex_value") requiredreviewrating_instance.website_ex_value = review.website_ex_value if (post_data.get("quality_value")): review.quality_value = post_data.get("quality_value") requiredreviewrating_instance.quality_value = review.quality_value if (post_data.get("service_value")): review.service_value = post_data.get("service_value") requiredreviewrating_instance.service_value = review.service_value if (post_data.get("shop_again")): review.shop_again = post_data.get("shop_again") requiredreviewrating_instance.shop_again = review.shop_again if (post_data.get("exchange_value")): review.exchange_value = post_data.get("exchange_value") optionalreviewrating_instance.exchange_value = review.exchange_value review.save() if isinstance(obj, BlogPost): blog_category = post_data.get("category") bought_category = None bought_category = BlogCategory.objects.get(slug=slugify(blog_category)) review.bought_category.add(bought_category) # the primary key for review will be generated when it is saved # and the reviewrating will need to store that primary key requiredreviewrating_instance.commentid = review.pk requiredreviewrating_manager.add(requiredreviewrating_instance) if post_data.get("exchange_value"): optionalreviewrating_instance.commentid = review.pk optionalreviewrating_manager.add(optionalreviewrating_instance) comment_was_posted.send(sender=review.__class__, comment=review, request=request) notify_emails = split_addresses(settings.COMMENTS_NOTIFICATION_EMAILS) if notify_emails: subject = _("New comment for: ") + unicode(obj) context = { "comment": review, "comment_url": add_cache_bypass(comment.get_absolute_url()), "request": request, "obj": obj, } send_mail_template(subject, "email/comment_notification", settings.DEFAULT_FROM_EMAIL, notify_emails, context, fail_silently=settings.DEBUG) return review
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)