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)
