def rating(request):
"""
Handle a ``RatingForm`` submission and redirect back to its
related object.
"""
response = initial_validation(request, "rating")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
url = add_cache_bypass(obj.get_absolute_url().split("#")[0])
response = redirect(url + "#rating-%s" % obj.id)
rating_form = RatingForm(request, obj, post_data)
if rating_form.is_valid():
rating_form.save()
if request.is_ajax():
# Reload the object and return the rating fields as json.
obj = obj.__class__.objects.get(id=obj.id)
rating_name = obj.get_ratingfield_name()
json = {}
for f in ("average", "count", "sum"):
json["rating_" + f] = getattr(obj, "%s_%s" % (rating_name, f))
response = HttpResponse(dumps(json))
if rating_form.undoing:
ratings = set(rating_form.previous) ^ set([rating_form.current])
else:
ratings = rating_form.previous + [rating_form.current]
set_cookie(response, "mezzanine-rating", ",".join(ratings))
return response
def comment(request, template="generic/comments.html", extra_context=None):
"""
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_class = import_dotted_path(settings.COMMENT_FORM_CLASS)
form = form_class(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}
context.update(extra_context or {})
return TemplateResponse(request, template, context)
def rating(request):
"""
Handle a ``RatingForm`` 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"])
url = add_cache_bypass(obj.get_absolute_url()) + "#rating-%s" % obj.id
except (KeyError, TypeError, AttributeError, ObjectDoesNotExist):
# Something was missing from the post so abort.
return HttpResponseRedirect("/")
try:
rating_value = int(request.POST["value"])
except (KeyError, ValueError):
return HttpResponseRedirect(url)
# There can only be one ``RatingField``, find its manager.
for field in obj._meta.many_to_many:
if isinstance(field, RatingField):
rating_manager = getattr(obj, field.name)
break
else:
raise TypeError("%s doesn't contain a RatingField." % obj)
ratings = request.COOKIES.get("mezzanine-rating", "").split(",")
rating_string = "%s.%s" % (request.POST["content_type"],
request.POST["object_pk"])
if rating_string in ratings:
# Already rated so abort.
return HttpResponseRedirect(url)
rating_manager.add(Rating(value=rating_value))
response = HttpResponseRedirect(url)
ratings.append(rating_string)
expiry = 60 * 60 * 24 * 365
set_cookie(response, "mezzanine-rating", ",".join(ratings), expiry)
return response
def rating(request):
"""
Handle a ``RatingForm`` submission and redirect back to its
related object.
"""
response = initial_validation(request, "rating")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
url = add_cache_bypass(obj.get_absolute_url().split("#")[0])
response = redirect(url + "#rating-%s" % obj.id)
rating_form = RatingForm(request, obj, post_data)
if rating_form.is_valid():
rating_form.save()
if request.is_ajax():
# Reload the object and return the rating fields as json.
obj = obj.__class__.objects.get(id=obj.id)
rating_name = obj.get_ratingfield_name()
json = {}
for f in ("average", "count", "sum"):
json["rating_" + f] = getattr(obj, "%s_%s" % (rating_name, f))
response = HttpResponse(dumps(json))
ratings = ",".join(rating_form.previous + [rating_form.current])
set_cookie(response, "mezzanine-rating", ratings)
return response
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
resource_mode = post_data.get('resource-mode', 'view')
request.session['resource-mode'] = resource_mode
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 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.user_name = best_name(comment.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)
notify_emails.append(obj.user.email)
reply_to_comment = comment.replied_to
if reply_to_comment is not None:
notify_emails.append(reply_to_comment.user.email)
if notify_emails:
subject = "[HydroShare Support] New comment by {c_name} for: {res_obj}".format(
c_name=comment.user_name, res_obj=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 rating(request):
"""
Handle a ``RatingForm`` 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"])
url = add_cache_bypass(obj.get_absolute_url()) + "#rating-%s" % obj.id
except (KeyError, TypeError, AttributeError, ObjectDoesNotExist):
# Something was missing from the post so abort.
return HttpResponseRedirect("/")
try:
rating_value = int(request.POST["value"])
except (KeyError, ValueError):
return HttpResponseRedirect(url)
# There can only be one ``RatingField``, find its manager.
for field in obj._meta.many_to_many:
if isinstance(field, RatingField):
rating_manager = getattr(obj, field.name)
break
else:
raise TypeError("%s doesn't contain a RatingField." % obj)
ratings = request.COOKIES.get("mezzanine-rating", "").split(",")
rating_string = "%s.%s" % (request.POST["content_type"],
request.POST["object_pk"])
if rating_string in ratings:
# Already rated so abort.
return HttpResponseRedirect(url)
rating_manager.add(Rating(value=rating_value))
response = HttpResponseRedirect(url)
ratings.append(rating_string)
expiry = 60 * 60 * 24 * 365
set_cookie(response, "mezzanine-rating", ",".join(ratings), expiry)
return response
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 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 comment(request, template="generic/comments.html"):
"""
Handle a ``ReviewForm`` submission and redirect back to its
related object.
"""
response = initial_validation(request, "comment")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
form = ReviewForm(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)
response = redirect(add_cache_bypass(comment.get_absolute_url()))
# Store commenter's details in a cookie for 90 days.
for field in ReviewForm.cookie_fields:
cookie_name = ReviewForm.cookie_prefix + field
cookie_value = post_data.get(field, "")
set_cookie(response, cookie_name, cookie_value)
"""
Send activity feed to those who follow this vendor page.
"""
if request.user.is_authenticated():
action.send(obj, verb=settings.GOT_REVIEW_VERB, target=comment )
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 set_device(request, device=""):
"""
Sets a device name in a cookie when a user explicitly wants to go
to the site for a particular device (eg mobile).
"""
response = redirect(add_cache_bypass(next_url(request) or "/"))
set_cookie(response, "mezzanine-device", device, 60 * 60 * 24 * 365)
return response
def set_device(request, device=""):
"""
Sets a device name in a cookie when a user explicitly wants to go
to the site for a particular device (eg mobile).
"""
response = redirect(add_cache_bypass(request.GET.get("next", "/")))
set_cookie(response, "mezzanine-device", device, 60 * 60 * 24 * 365)
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"]).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 save(self, request):
"""
Saves a new comment and sends any notification emails.
"""
comment = self.get_comment_object()
obj = comment.content_object
comment.user = request.user
user_name = request.user.get_full_name()
if not user_name:
user_name = request.user.username
comment.user_name = user_name
# comment.email = request.user.email
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")
# Mezzanine's duplicate check that also checks `replied_to_id`.
lookup = {
"content_type": comment.content_type,
"object_pk": comment.object_pk,
"user_name": comment.user_name,
"user_email": comment.user_email,
"user_url": comment.user_url,
"replied_to_id": comment.replied_to_id,
}
for duplicate in self.get_comment_model().objects.filter(**lookup):
if (duplicate.submit_date.date() == comment.submit_date.date() and
duplicate.comment == comment.comment):
return duplicate
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 is_authenticated(request.user):
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")
# Mezzanine's duplicate check that also checks `replied_to_id`.
lookup = {
"content_type": comment.content_type,
"object_pk": comment.object_pk,
"user_name": comment.user_name,
"user_email": comment.user_email,
"user_url": comment.user_url,
"replied_to_id": comment.replied_to_id,
}
for duplicate in self.get_comment_model().objects.filter(**lookup):
if (duplicate.submit_date.date() == comment.submit_date.date()
and duplicate.comment == comment.comment):
return duplicate
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 spam(request, template="generic/comments.html"):
response = initial_validation(request, "spam")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
form = CommentFlagForm(request, obj, post_data)
if form.is_valid():
url = obj.get_absolute_url()
if is_spam(request, form, url):
return redirect(url)
form.save(request)
messages.info(request, _('Se guardó como spam'))
response = redirect(add_cache_bypass(obj.get_absolute_url()))
# for field in CommentFlagForm.cookie_fields:
# cookie_name = CommentFlagForm.cookie_prefix + field
# cookie_value = post_data.get(field, "")
# set_cookie(response, cookie_name, cookie_value)
return response
context = {"obj": obj, "spam_form": form}
response = render(request, template, context)
return response
def spam(request, template="generic/comments.html"):
response = initial_validation(request, "spam")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
form = CommentFlagForm(request, obj, post_data)
if form.is_valid():
url = obj.get_absolute_url()
if is_spam(request, form, url):
return redirect(url)
form.save(request)
messages.info(request, _('Se guardó como spam'))
response = redirect(add_cache_bypass(obj.get_absolute_url()))
# for field in CommentFlagForm.cookie_fields:
# cookie_name = CommentFlagForm.cookie_prefix + field
# cookie_value = post_data.get(field, "")
# set_cookie(response, cookie_name, cookie_value)
return response
context = {"obj": obj, "spam_form": form}
response = render(request, template, context)
return 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 rating(request):
"""
Handle a ``RatingForm`` submission and redirect back to its
related object.
"""
response = initial_validation(request, "rating")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
url = obj.get_absolute_url()
url = add_cache_bypass(url.split("#")[0]) + "#rating-%s" % obj.id
response = redirect(url)
rating_form = RatingForm(request, obj, post_data)
if rating_form.is_valid():
rating_form.save()
if request.is_ajax():
# Reload the object and return the new rating.
obj = obj.__class__.objects.get(id=obj.id)
fields = ("rating_avg", "rating_count", "rating_sum")
json = dumps(dict([(f, getattr(obj, f)) for f in fields]))
response = HttpResponse(json)
ratings = ",".join(rating_form.previous + [rating_form.current])
set_cookie(response, "mezzanine-rating", ratings)
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)
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 write_review(request, content_type_id, object_id, template="generic/includes/write_review.html"):
store = request.GET.get('store', 'None')
parent = None
if store != 'None':
store = store.lower()
try:
parent = BlogPost.objects.get(title__iexact=store)
content_type_id = ContentType.objects.get_for_model(parent).pk
object_id = parent.pk
except:
pass
if not parent:
ctype = get_object_or_404(ContentType, pk=content_type_id)
parent = get_object_or_404(ctype.model_class(), pk=object_id)
prefix = "write_review"
if request.method == 'POST':
response = initial_validation_review(request, prefix, content_type_id, object_id, store)
if isinstance(response, HttpResponse):
return response
obj, post_data = response
form = ReviewForm(request, obj, request.POST)
if form.is_valid() and request.user.is_authenticated():
url = obj.get_absolute_url()
if is_spam(request, form, url):
return redirect(url)
comment = form.save(request)
"""
Send activity feed to those who follow this vendor page.
"""
if request.user.is_authenticated():
action.send(obj, verb=settings.GOT_REVIEW_VERB, target=comment )
if request.is_ajax():
html = render_to_string('generic/includes/comment_ajax.html', { 'comment': comment, 'request':request })
res = {'html': html,
'store': obj.title,
'success':True}
response = HttpResponse( simplejson.dumps(res), 'application/json' )
# Store commenter's details in a cookie for 90 days.
for field in ReviewForm.cookie_fields:
cookie_name = ReviewForm.cookie_prefix + field
cookie_value = post_data.get(field, "")
set_cookie(response, cookie_name, cookie_value)
return response
else:
response = redirect(add_cache_bypass(comment.get_absolute_url()))
return response
elif request.is_ajax() and form.errors:
return HttpResponse( simplejson.dumps({"errors": form.errors,
"success":False}), 'application/json')
else:
post_data = None
posted_session_key = "unauthenticated_" + prefix
post_session_generic_review_store_key = "unauthenticated_store_" + prefix
if posted_session_key in request.session:
post_data = request.session.pop(posted_session_key)
form = ReviewForm(request, parent, post_data)
if post_session_generic_review_store_key in request.session:
request.session.pop(post_session_generic_review_store_key)
else:
form = ReviewForm(request, parent)
form.fields['overall_value'].widget = forms.HiddenInput()
form.fields['price_value'].widget = forms.HiddenInput()
form.fields['website_ex_value'].widget = forms.HiddenInput()
form.fields['quality_value'].widget = forms.HiddenInput()
form.fields['service_value'].widget = forms.HiddenInput()
form.fields['exchange_value'].widget = forms.HiddenInput()
action_url = reverse("write_review", kwargs={
'content_type_id':content_type_id,
'object_id':object_id
})
if store != 'None':
action_url += '?store=' + store
context = {"new_review":True, "obj": parent, "posted_comment_form": form, "action_url": action_url }
response = render(request, template, context)
return response
def edit_review(request, review_id, template="generic/includes/write_review.html"):
if not review_id :
raise Http404()
review_obj = Review.objects.get(id=review_id)
if review_obj and review_obj.user != request.user:
raise Http404()
context = RequestContext(request)
parent_obj = review_obj.content_object
if request.method == 'POST':
form = ReviewForm(request, parent_obj, request.POST )
if form.is_valid():
url = review_obj.get_absolute_url()
if is_spam(request, form, url):
return redirect(url)
review_obj.comment = form.cleaned_data['comment']
review_obj.title = form.cleaned_data['title']
review_obj.overall_value = form.cleaned_data['overall_value']
review_obj.price_value = form.cleaned_data['price_value']
review_obj.website_ex_value = form.cleaned_data['website_ex_value']
review_obj.quality_value = form.cleaned_data['quality_value']
review_obj.service_value = form.cleaned_data['service_value']
exchange_value = form.cleaned_data['exchange_value']
"""
exchange_value is not a required field. Can contain null data as well. Therefore need to handle it seperately.
"""
if exchange_value == '':
review_obj.exchange_value = None
else:
review_obj.exchange_value = exchange_value
review_obj.shop_again = form.cleaned_data['shop_again']
blog_category = form.cleaned_data['category']
bought_category = None
try:
bought_category = BlogCategory.objects.get(slug=slugify(blog_category))
except:
pass
try:
reviewRatingObj = RequiredReviewRating.objects.get(commentid=review_obj.id)
reviewRatingObj.overall_value = review_obj.overall_value
reviewRatingObj.price_value = review_obj.price_value
reviewRatingObj.website_ex_value = review_obj.website_ex_value
reviewRatingObj.quality_value = review_obj.quality_value
reviewRatingObj.service_value = review_obj.service_value
reviewRatingObj.shop_again = review_obj.shop_again
reviewRatingObj.save()
optReviewRatingObj = OptionalReviewRating.objects.get(commentid=review_obj.id)
optReviewRatingObj.exchange_value = review_obj.service_value
optReviewRatingObj.save()
except:
pass
review_obj.save()
if bought_category:
for blog_category in review_obj.bought_category.all():
review_obj.bought_category.remove(blog_category)
review_obj.bought_category.add(bought_category)
if request.is_ajax():
template = 'generic/includes/comment_ajax.html'
review_page = request.GET.get('reviewpage', '0')
if review_page == '1':
template = 'generic/includes/review_ajax.html'
html = render_to_string(template, { 'comment': review_obj, 'request':request })
res = { 'html': html,
'store' : review_obj.content_object.title,
'success':True}
response = HttpResponse( simplejson.dumps(res), 'application/json' )
else:
response = redirect(add_cache_bypass(review_obj.get_absolute_url()))
return response
elif form.errors:
return HttpResponse(simplejson.dumps({"errors": form.errors}), 'application/json' )
else:
data = {
"comment" : review_obj.comment,
"title" : review_obj.title,
"overall_value" : review_obj.overall_value,
"price_value" : review_obj.price_value,
"website_ex_value" : review_obj.website_ex_value,
"quality_value" : review_obj.quality_value,
"service_value" : review_obj.service_value,
"exchange_value" : review_obj.exchange_value,
"shop_again" : review_obj.shop_again,
"category" : review_obj.bought_category.all()[0] #we support multiple bought categoires but there's no multiselect option in UI.
}
form = ReviewForm(request, parent_obj, initial=data)
form.fields['overall_value'].widget = forms.HiddenInput()
form.fields['price_value'].widget = forms.HiddenInput()
form.fields['website_ex_value'].widget = forms.HiddenInput()
form.fields['quality_value'].widget = forms.HiddenInput()
form.fields['service_value'].widget = forms.HiddenInput()
form.fields['exchange_value'].widget = forms.HiddenInput()
"""
Review pages which list all the reviews require a template different than edit review template on store page.
For such a case reviewpage=1 query parameter should be present.
"""
review_page = request.GET.get('reviewpage', '0')
action_url = reverse("edit_review", kwargs={'review_id':review_id})
action_url = action_url + '?reviewpage='+review_page
context = {
"posted_comment_form": form,
"action_url":action_url,
"new_review":False,
"review_id": review_id
}
response = render(request, template, context)
return response
