def save(self, request):
"""
Saves a new comment and sends any notification emails.
"""
comment = self.get_comment_object()
obj = comment.content_object
if request.user.is_authenticated():
comment.user = request.user
comment.by_author = request.user == getattr(obj, "user", None)
comment.ip_address = ip_for_request(request)
comment.replied_to_id = self.data.get("replied_to")
comment.save()
comment_was_posted.send(sender=comment.__class__,
comment=comment,
request=request)
notify_emails = split_addresses(settings.COMMENTS_NOTIFICATION_EMAILS)
if notify_emails:
subject = ugettext("New comment for: ") + str(obj)
context = {
"comment": comment,
"comment_url": add_cache_bypass(comment.get_absolute_url()),
"request": request,
"obj": obj,
}
send_mail_template(subject, "email/comment_notification",
settings.DEFAULT_FROM_EMAIL, notify_emails,
context)
return comment
def question_and_answer_page_processor(request, page):
if request.method == 'POST':
url = page.get_absolute_url() + "?sent=1"
question_form = AskedQuestionForm(data=request.POST)
question = question_form.save(page.qapage, request.user)
fields = [('questioner', question.questioner),
('question', question.question)]
responder_mail = split_addresses(page.qapage.responder_mail)
if responder_mail:
send_mail_template(page.title,
'email/form_response',
None,
responder_mail,
context={
'message':
_('A new question is waiting for you!'),
'fields':
fields
})
return redirect(url)
question_form = AskedQuestionForm()
return {'form': question_form}
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 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 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 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 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 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 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 question_and_answer_page_processor(request, page):
if request.method == 'POST':
url = page.get_absolute_url() + "?sent=1"
question_form = AskedQuestionForm(data=request.POST)
question = question_form.save(page.qapage, request.user)
fields = [('questioner', question.questioner), ('question', question.question)]
responder_mail = split_addresses(page.qapage.responder_mail)
if responder_mail:
send_mail_template(page.title, 'email/form_response', None, responder_mail,
context={'message': _('A new question is waiting for you!'), 'fields': fields})
return redirect(url)
question_form = AskedQuestionForm()
return {'form': question_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)
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 = split_addresses(page.form.email_copies)
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 ipn(request):
api = PolyBanking(settings.POLYBANKING_SERVER, settings.POLYBANKING_ID, settings.POLYBANKING_KEY_REQUEST, settings.POLYBANKING_KEY_IPN, settings.POLYBANKING_KEY_API)
ok, message, ref, status, status_ok, date = api.check_ipn(request.POST)
if ok:
payment = get_object_or_404(Payment, pk=ref.split('-')[-1])
payment.is_valid = status_ok
payment.save()
entry = payment.entry
subject = payment.entry.form.final_confirmation_subject
context = {
"message": payment.entry.form.final_confirmation_email,
}
if status_ok:
email_from = payment.entry.form.email_from or settings.DEFAULT_FROM_EMAIL
for field in payment.entry.form.fields.all():
if field.field_type == EMAIL:
email_to = payment.entry.fields.filter(field_id=field.id).first().value
if email_to and payment.entry.form.send_email:
send_mail_template(subject, "email/form_response_paid", 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(payment.entry.form.email_copies)
if email_copies:
send_mail_template(subject, "email/form_response_copies_paid",
email_from, email_copies, context, headers=headers)
return HttpResponse('')
def from_bank_upal(request, transaction):
bank_token = request.GET.get('trans_id')
validation_hash = request.GET.get('valid')
if bank_token == transaction.bank_token:
our_validation_md5 = hashlib.md5()
our_validation_md5.update("{}{}{}{}".format(transaction.price_group.payment_form_page.payment_gateway.gateway_id,
transaction.payment_amount,
transaction.price_group.payment_form_page.payment_gateway.gateway_api,
transaction.random_token))
if our_validation_md5.hexdigest() == validation_hash:
send_payment_main = False
if transaction.is_payed is None or transaction.is_payed is False:
transaction.is_payed = True
transaction.payment_time = timezone.now()
transaction.save()
send_payment_main = True
form = transaction.price_group.payment_form_page.payment_form.form
form_fields = form.fields.all().order_by("id")
field_entries = get_transaction_entries(transaction)
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
field_tuples = []
email_to = None
for field, field_entry in zip(form_fields, field_entries):
field_tuples.append((field.label, field_entry.value))
if field.is_a(fields.EMAIL):
email_to = field_entry.value
field_tuples.append((_('Price Group'), transaction.price_group.group_identifier))
field_tuples.append((_('Payment in Rials'), transaction.payment_amount))
subject = form.email_subject
context = {
"fields": field_tuples,
"message": form.email_message,
"request": request,
}
if send_payment_main:
send_mail_template(subject, "email/form_response", email_from, email_to, context)
email_copies = split_addresses(form.email_copies)
if email_copies:
send_mail_template(subject, "email/form_response_copies",
email_from, email_copies, context)
return render(request, 'pages/message.html', {"page": transaction.price_group.payment_form_page,
"title": _("Successful Payment Transaction"),
"context": context})
else:
# print(our_validation_md5.hexdigest())
# print(validation_hash)
transaction.is_payed = False
transaction.save()
def from_bank_zpal(request, transaction):
authority = request.GET.get('Authority')
if authority == transaction.authority:
client = Client('https://www.zarinpal.com/pg/services/WebGate/wsdl')
validation_parameters = {
'MerchantID': PaymentGateway.objects.get(type='zpal').gateway_id,
'Authority': authority,
'Amount': transaction.payment_amount/10,
}
validation_request = client.service.PaymentVerification(**validation_parameters)
if validation_request.Status == 100:
send_payment_main = False
if transaction.is_payed is None or transaction.is_payed is False:
transaction.is_payed = True
transaction.payment_time = timezone.now()
transaction.ref_id = validation_request.RefID
transaction.save()
send_payment_main = True
form = transaction.price_group.payment_form_page.payment_form.form
form_fields = form.fields.all().order_by("id")
field_entries = get_transaction_entries(transaction)
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
field_tuples = []
email_to = None
for field, field_entry in zip(form_fields, field_entries):
field_tuples.append((field.label, field_entry.value))
if field.is_a(fields.EMAIL):
email_to = field_entry.value
field_tuples.append((_('Price Group'), transaction.price_group.group_identifier))
field_tuples.append((_('Payment in Rials'), transaction.payment_amount))
subject = form.email_subject
context = {
"fields": field_tuples,
"message": form.email_message,
"request": request,
}
if send_payment_main:
send_mail_template(subject, "email/form_response", email_from, email_to, context)
email_copies = split_addresses(form.email_copies)
if email_copies:
send_mail_template(subject, "email/form_response_copies",
email_from, email_copies, context)
return render(request, 'pages/message.html', {"page": transaction.price_group.payment_form_page,
"title": _("Successful Payment Transaction"),
"context": context})
else:
# print(our_validation_md5.hexdigest())
# print(validation_hash)
transaction.is_payed = False
transaction.save()
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
