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 ``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 modularpage_processor(request, page):
formblock_ct = ContentType.objects.get(app_label='clubhouse_forms',\
model='formblock')
# TODO: Fix this to find form objects in any of the BlockContexts registered here
formblocks = page.modularpage.content.filter(block_type=formblock_ct)
from clubhouse.forms import Initialised
for formblock in formblocks:
registry_key = 'form:%s' % formblock.block_object.pk
form_model = formblock.block_object.form
form = FormForForm(formblock.block_object.form, RequestContext(request),
None, None)
post_data = request.POST or {}
if form.submit_key in post_data:
form = FormForForm(formblock.block_object.form,
RequestContext(request), request.POST, request.FILES or None)
if form.is_valid():
url = page.get_absolute_url()
if is_spam(request, form, url):
return redirect(url)
attachments = []
for f in form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form.save()
subject = form_model.email_subject
if not subject:
subject = "%s - %s" % (form_model.title, entry.entry_time)
fields = [(v.label, format_value(form.cleaned_data[k]))
for (k, v) in form.fields.items()]
context = {
"fields": fields,
"message": form_model.email_message,
"request": request,
}
email_from = form_model.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form.email_to()
if email_to and form_model.send_email:
send_mail_template(subject, "email/form_response", email_from,
email_to, context)
headers = None
if email_to:
# Add the email entered as a Reply-To header
headers = {'Reply-To': email_to}
email_copies = split_addresses(form_model.email_copies)
if email_copies:
send_mail_template(subject, "email/form_response_copies",
email_from, email_copies, context,
attachments=attachments, headers=headers)
form_valid.send(sender=request, form=form, entry=entry)
form.is_submitted = True
else:
form_invalid.send(sender=request, form=form)
Initialised.register(registry_key, form)
return {}
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 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 {})
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"]).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 form_processor(request, page, response_redirect=True):
"""
Display a built form and handle submission.
"""
form = FormForForm(
page.form, RequestContext(request), request.POST or None, request.FILES or None
)
if form.is_valid():
url = page.get_absolute_url() + "?sent=1"
if is_spam(request, form, url):
return redirect(url)
attachments = []
for f in form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form.save()
subject = page.form.email_subject
if not subject:
subject = "%s - %s" % (page.form.title, entry.entry_time)
fields = [
(v.label, format_value(form.cleaned_data[k]))
for (k, v) in form.fields.items()
]
context = {
"fields": fields,
"message": page.form.email_message,
"request": request,
}
email_from = page.form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form.email_to()
if email_to and page.form.send_email:
send_mail_template(
subject, "email/form_response", email_from, email_to, context
)
headers = None
if email_to:
# Add the email entered as a Reply-To header
headers = {"Reply-To": email_to}
email_copies = split_addresses(page.form.email_copies)
if email_copies:
send_mail_template(
subject,
"email/form_response_copies",
email_from,
email_copies,
context,
attachments=attachments,
headers=headers,
)
form_valid.send(sender=request, form=form, entry=entry)
if response_redirect:
return redirect(url)
form_invalid.send(sender=request, form=form)
return {"form": form}
def form_processor(request, page):
"""
Display a built form and handle submission.
"""
form = FormForForm(page.form, request.POST or None, request.FILES or None)
if form.is_valid():
url = page.get_absolute_url() + "?sent=1"
if is_spam(request, form, url):
return redirect(url)
entry = form.save()
subject = page.form.email_subject
if not subject:
subject = "%s - %s" % (page.form.title, entry.entry_time)
fields = [(v.label, format_value(form.cleaned_data[k]))
for (k, v) in form.fields.items()]
context = {
"fields": fields,
"message": page.form.email_message,
"request": request,
}
email_from = page.form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form.email_to()
if email_to and page.form.send_email:
send_mail_template(subject,
"email/form_response",
email_from,
email_to,
context,
fail_silently=settings.DEBUG)
if not settings.FORMS_DISABLE_SEND_FROM_EMAIL_FIELD:
# Send from the email entered,
# unless FORMS_DISABLE_SEND_FROM_EMAIL_FIELD is True.
email_from = email_to or email_from
email_copies = page.form.email_copies.split(",")
email_copies = [e.strip() for e in email_copies if e.strip()]
if email_copies:
attachments = []
for f in form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
send_mail_template(subject,
"email/form_response",
email_from,
email_copies,
context,
attachments=attachments,
fail_silently=settings.DEBUG)
form_valid.send(sender=request, form=form, entry=entry)
return redirect(url)
form_invalid.send(sender=request, form=form)
return {"form": form}
def form_processor(request, page):
"""
Display a built form and handle submission.
"""
form = FormForForm(page.form, RequestContext(request),
request.POST or None, request.FILES or None)
if form.is_valid():
url = page.get_absolute_url() + "?sent=1"
if is_spam(request, form, url):
return redirect(url)
attachments = []
for f in form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form.save()
subject = page.form.email_subject
if not subject:
subject = "%s - %s" % (page.form.title, entry.entry_time)
fields = [(v.label, format_value(form.cleaned_data[k]))
for (k, v) in form.fields.items()]
context = {
"fields": fields,
"message": page.form.email_message,
"request": request,
"page": page,
"entry_id": entry.id,
}
url += '&entry_id=' + str(entry.pk)
email_from = page.form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form.email_to()
if email_to and page.form.send_email:
send_mail_template(subject, "email/form_response", email_from,
email_to, context)
headers = None
if email_to:
# Add the email entered as a Reply-To header
headers = {'Reply-To': email_to}
email_copies = split_addresses(page.form.email_copies)
if email_copies:
send_mail_template(subject, "email/form_response_copies",
email_from, email_copies, context,
attachments=attachments, headers=headers)
form_valid.send(sender=request, form=form, entry=entry)
return redirect(url)
form_invalid.send(sender=request, form=form)
return {"form": form}
def ajax_form_processor(request, page):
"""
Handle a Mezzanine form submissions if and only if the request
is ajax, otherwise the default processor will run.
"""
if request.is_ajax():
form = FormForForm(page.form, RequestContext(request),
request.POST or None, request.FILES or None)
if form.is_valid():
form.save()
url = page.get_absolute_url() + "?sent=1"
if is_spam(request, form, url):
return redirect(url)
attachments = []
for f in form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form.save()
subject = page.form.email_subject
if not subject:
subject = "%s - %s" % (page.form.title, entry.entry_time)
fields = [(v.label, format_value(form.cleaned_data[k]))
for (k, v) in form.fields.items()]
context = {
"fields": fields,
"message": page.form.email_message,
"request": request,
}
email_from = page.form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form.email_to()
if email_to and page.form.send_email:
send_mail_template(subject, "email/form_response", email_from,
email_to, context)
headers = None
if email_to:
# Add the email entered as a Reply-To header
headers = {'Reply-To': email_to}
email_copies = split_addresses(page.form.email_copies)
if email_copies:
send_mail_template(subject, "email/form_response_copies",
email_from, email_copies, context,
attachments=attachments, headers=headers)
form_valid.send(sender=request, form=form, entry=entry)
return render(request, 'includes/form_content_only.html', {'form': form, 'ok': True})
else:
form_invalid.send(sender=request, form=form)
return render(request, 'includes/form_content_only.html', {'form': form})
def ajax_form_processor(request, page):
"""
Handle a Mezzanine form submissions if and only if the request
is ajax, otherwise the default processor will run.
"""
if request.is_ajax():
form = FormForForm(page.form, RequestContext(request), request.POST or None, request.FILES or None)
if form.is_valid():
form.save()
url = page.get_absolute_url() + "?sent=1"
if is_spam(request, form, url):
return redirect(url)
attachments = []
for f in form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form.save()
subject = page.form.email_subject
if not subject:
subject = "%s - %s" % (page.form.title, entry.entry_time)
fields = [(v.label, format_value(form.cleaned_data[k])) for (k, v) in form.fields.items()]
context = {"fields": fields, "message": page.form.email_message, "request": request}
email_from = page.form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form.email_to()
if email_to and page.form.send_email:
send_mail_template(subject, "email/form_response", email_from, email_to, context)
headers = None
if email_to:
# Add the email entered as a Reply-To header
headers = {"Reply-To": email_to}
email_copies = split_addresses(page.form.email_copies)
if email_copies:
send_mail_template(
subject,
"email/form_response_copies",
email_from,
email_copies,
context,
attachments=attachments,
headers=headers,
)
form_valid.send(sender=request, form=form, entry=entry)
return render(request, "includes/form_content_only.html", {"form": form, "ok": True})
else:
form_invalid.send(sender=request, form=form)
return render(request, "includes/form_content_only.html", {"form": form})
def form_processor(request, page):
"""
Display a built form and handle submission.
"""
form = FormForForm(page.form, request.POST or None, request.FILES or None)
if form.is_valid():
url = page.get_absolute_url() + "?sent=1"
if is_spam(request, form, url):
return redirect(url)
entry = form.save()
subject = page.form.email_subject
if not subject:
subject = "%s - %s" % (page.form.title, entry.entry_time)
fields = [(v.label, format_value(form.cleaned_data[k]))
for (k, v) in form.fields.items()]
context = {
"fields": fields,
"message": page.form.email_message,
"request": request,
}
email_from = page.form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form.email_to()
if email_to and page.form.send_email:
send_mail_template(subject, "email/form_response", email_from,
email_to, context, fail_silently=settings.DEBUG)
if not settings.FORMS_DISABLE_SEND_FROM_EMAIL_FIELD:
# Send from the email entered,
# unless FORMS_DISABLE_SEND_FROM_EMAIL_FIELD is True.
email_from = email_to or email_from
email_copies = page.form.email_copies.split(",")
email_copies = [e.strip() for e in email_copies if e.strip()]
if email_copies:
attachments = []
for f in form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
send_mail_template(subject, "email/form_response", email_from,
email_copies, context, attachments=attachments,
fail_silently=settings.DEBUG)
form_valid.send(sender=request, form=form, entry=entry)
return redirect(url)
form_invalid.send(sender=request, form=form)
return {"form": form}
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 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
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 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
