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