def message(request, group_slug, template_name="user_groups/message.html"):
"""
Send a message to the group
"""
from tendenci.apps.emails.models import Email
group = get_object_or_404(Group, slug=group_slug)
EventLog.objects.log(instance=group)
members = GroupMembership.objects.filter(group=group, status=True, status_detail="active")
num_members = members.count()
form = MessageForm(request.POST or None, request=request, num_members=num_members)
if request.method == "POST" and form.is_valid():
email = Email()
email.sender_display = request.user.get_full_name()
email.sender = get_setting("site", "global", "siteemailnoreplyaddress")
email.reply_to = email.sender
email.content_type = email.CONTENT_TYPE_HTML
email.subject = form.cleaned_data["subject"]
email.body = form.cleaned_data["body"]
email.save(request.user)
# send email to myself (testing email)
if form.cleaned_data["is_test"]:
email.recipient = request.user.email
email.send()
messages.add_message(request, messages.SUCCESS, _("Successfully sent test email to yourself"))
EventLog.objects.log(instance=email)
else:
# send email to members
for member in members:
email.recipient = member.member.email
email.send()
messages.add_message(
request,
messages.SUCCESS,
_("Successfully sent email to all %(num)s members in this group" % {"num": num_members}),
)
EventLog.objects.log(instance=email)
return redirect("group.detail", group_slug=group_slug)
else:
print "form errors", form.errors.items()
return render(request, template_name, {"group": group, "num_members": num_members, "form": form})
def send_organizer_confirmation(self, event):
from tendenci.apps.emails.models import Email
from tendenci.apps.site_settings.utils import get_setting
email = Email()
if event.organizer and event.organizer.user \
and event.organizer.user.email:
email.recipient = event.organizer.user.email
else:
email.recipient = get_setting('module', 'events', 'admin_emails')
if not email.recipient:
email.recipient = get_setting('site', 'global',
'sitecontactemail')
email.subject = '%s Event Reminders Distributed for: %s' % (
get_setting('site', 'global', 'sitedisplayname'), event.title)
email.body = self.get_reminder_conf_body(event)
email.send()
def email_invoice(request,
invoice_id,
form_class=EmailInvoiceForm,
template_name='invoices/email_invoice.html'):
if not request.user.profile.is_superuser:
raise Http403
invoice = get_object_or_404(Invoice, pk=invoice_id)
if request.method == "POST":
email = Email()
form = form_class(request.POST, instance=email)
if form.is_valid():
email = form.save(commit=False)
email.sender_display = request.user.get_full_name()
email.reply_to = request.user.email
email.recipient = form.cleaned_data['recipient']
email.content_type = "html"
email.recipient_cc = form.cleaned_data['cc']
attachment = form.cleaned_data['attachment']
kwargs = {}
if attachment:
result = invoice_pdf(request, invoice)
kwargs['attachments'] = [("invoice_{}.pdf".format(invoice.id),
result.getvalue(), 'application/pdf')
]
email.send(**kwargs)
EventLog.objects.log(instance=email)
msg_string = 'Successfully sent email invoice to {}.'.format(
email.recipient)
messages.add_message(request, messages.SUCCESS, msg_string)
return HttpResponseRedirect(
reverse('invoice.view', args=([invoice_id])))
else:
template = get_template("invoices/email_invoice_template.html")
body_initial = template.render(context={'invoice': invoice},
request=request)
form = form_class(
initial={
'subject': 'Invoice for {}'.format(invoice.title),
'recipient': invoice.bill_to_email,
'body': body_initial
})
return render_to_resp(request=request,
template_name=template_name,
context={
'invoice': invoice,
'form': form
})
def send_organizer_confirmation(self, event):
from tendenci.apps.emails.models import Email
from tendenci.apps.site_settings.utils import get_setting
email = Email()
if event.organizer and event.organizer.user \
and event.organizer.user.email:
email.recipient = event.organizer.user.email
else:
email.recipient = get_setting('module', 'events', 'admin_emails')
if not email.recipient:
email.recipient = get_setting('site', 'global',
'sitecontactemail')
email.subject = '%s Event Reminders Distributed for: %s' % (
get_setting('site', 'global',
'sitedisplayname'),
event.title
)
email.body = self.get_reminder_conf_body(event)
email.send()
def email_invoice(request, invoice_id, form_class=EmailInvoiceForm,
template_name='invoices/email_invoice.html'):
if not request.user.profile.is_superuser:
raise Http403
invoice = get_object_or_404(Invoice, pk=invoice_id)
if request.method == "POST":
email = Email()
form = form_class(request.POST, instance=email)
if form.is_valid():
email = form.save(commit=False)
email.sender_display = request.user.get_full_name()
email.reply_to = request.user.email
email.recipient = form.cleaned_data['recipient']
email.content_type = "html"
email.recipient_cc = form.cleaned_data['cc']
attachment = form.cleaned_data['attachment']
kwargs = {}
if attachment:
result = invoice_pdf(request, invoice)
kwargs['attachments'] = [("invoice_{}.pdf".format(invoice.id),
result.getvalue(),
'application/pdf')]
email.send(**kwargs)
EventLog.objects.log(instance=email)
msg_string = 'Successfully sent email invoice to {}.'.format(email.recipient)
messages.add_message(request, messages.SUCCESS, msg_string)
return HttpResponseRedirect(reverse('invoice.view', args=([invoice_id])))
else:
template = get_template("invoices/email_invoice_template.html")
body_initial = template.render(RequestContext(request, {
'invoice': invoice,}))
form = form_class(initial={'subject': 'Invoice for {}'.format(invoice.title),
'recipient': invoice.bill_to_email,
'body': body_initial})
return render_to_response(template_name, {
'invoice': invoice,
'form': form
},context_instance=RequestContext(request))
def email_script_errors(err_msg):
"""Send error message to us in case of an error.
"""
email = Email()
email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email.sender_display = get_setting('site', 'global', 'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
now = datetime.now()
nowstr = time.strftime("%d-%b-%y %I:%M %p", now.timetuple())
email.recipient = get_script_support_emails()
if email.recipient:
email.body = '%s \n\nTime Submitted: %s\n' % (err_msg, nowstr)
email.content_type = "text"
email.subject = 'Error Setting Up Campaign Monitor Account on New Site %s' % site_url
email.send()
def email_script_errors(err_msg):
"""Send error message to us in case of an error.
"""
email = Email()
email.sender = get_setting('site', 'global',
'siteemailnoreplyaddress')
email.sender_display = get_setting('site', 'global',
'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
now = datetime.now()
nowstr = time.strftime("%d-%b-%y %I:%M %p", now.timetuple())
email.recipient = get_script_support_emails()
if email.recipient:
email.body = '%s \n\nTime Submitted: %s\n' % (err_msg, nowstr)
email.content_type = "text"
email.subject = 'Error Setting Up Campaign Monitor Account on New Site %s' % site_url
email.send()
def form_detail(request, slug, template="forms/form_detail.html"):
"""
Display a built form and handle submission.
"""
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=slug)
if not has_view_perm(request.user, 'forms.view_form', form):
raise Http403
# If form has a recurring payment, make sure the user is logged in
if form.recurring_payment:
[email_field] = form.fields.filter(
field_type__iexact='EmailVerificationField')[:1] or [None]
if request.user.is_anonymous() and not email_field:
# anonymous user - if we don't have the email field, redirect to login
response = redirect('auth_login')
response['Location'] += '?next=%s' % form.get_absolute_url()
return response
if request.user.is_superuser and not email_field:
messages.add_message(
request, messages.WARNING,
'Please edit the form to include an email field ' +
'as it is required for setting up a recurring ' +
'payment for anonymous users.')
form_for_form = FormForForm(form, request.user, request.POST or None,
request.FILES or None)
if form.custom_payment and not form.recurring_payment:
billing_form = BillingForm(request.POST or None)
if request.user.is_authenticated():
billing_form.initial = {
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'email': request.user.email
}
else:
billing_form = None
for field in form_for_form.fields:
field_default = request.GET.get(field, None)
if field_default:
form_for_form.fields[field].initial = field_default
if request.method == "POST":
if form_for_form.is_valid() and (not billing_form
or billing_form.is_valid()):
entry = form_for_form.save()
entry.entry_path = request.POST.get("entry_path", "")
if request.user.is_anonymous():
if entry.get_email_address():
emailfield = entry.get_email_address()
firstnamefield = entry.get_first_name()
lastnamefield = entry.get_last_name()
phonefield = entry.get_phone_number()
password = ''
for i in range(0, 10):
password += random.choice(string.ascii_lowercase +
string.ascii_uppercase)
user_list = User.objects.filter(
email=emailfield).order_by('-last_login')
if user_list:
anonymous_creator = user_list[0]
else:
anonymous_creator = User(username=emailfield[:30],
email=emailfield,
first_name=firstnamefield,
last_name=lastnamefield)
anonymous_creator.set_password(password)
anonymous_creator.is_active = False
anonymous_creator.save()
anonymous_profile = Profile(user=anonymous_creator,
owner=anonymous_creator,
creator=anonymous_creator,
phone=phonefield)
anonymous_profile.save()
entry.creator = anonymous_creator
else:
entry.creator = request.user
entry.save()
entry.set_group_subscribers()
# Email
subject = generate_email_subject(form, entry)
email_headers = {} # content type specified below
if form.email_from:
email_headers.update({'Reply-To': form.email_from})
# Email to submitter
# fields aren't included in submitter body to prevent spam
submitter_body = generate_submitter_email_body(
entry, form_for_form)
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form_for_form.email_to()
is_spam = Email.is_blocked(email_to)
if is_spam:
# log the spam
description = "Email \"{0}\" blocked because it is listed in email_blocks.".format(
email_to)
EventLog.objects.log(instance=form, description=description)
if form.completion_url:
return HttpResponseRedirect(form.completion_url)
return redirect("form_sent", form.slug)
email = Email()
email.subject = subject
email.reply_to = form.email_from
if email_to and form.send_email and form.email_text:
# Send message to the person who submitted the form.
email.recipient = email_to
email.body = submitter_body
email.send(fail_silently=True)
# Email copies to admin
admin_body = generate_admin_email_body(entry, form_for_form)
email_from = email_to or email_from # Send from the email entered.
email_headers = {} # Reset the email_headers
email_headers.update({'Reply-To': email_from})
email_copies = [
e.strip() for e in form.email_copies.split(',') if e.strip()
]
subject = subject.encode(errors='ignore')
email_recipients = entry.get_function_email_recipients()
# reply_to of admin emails goes to submitter
email.reply_to = email_to
if email_copies or email_recipients:
# prepare attachments
attachments = []
try:
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
except ValueError:
attachments = []
for field_entry in entry.fields.all():
if field_entry.field.field_type == 'FileField':
try:
f = default_storage.open(field_entry.value)
except IOError:
pass
else:
f.seek(0)
attachments.append(
(f.name.split('/')[-1], f.read()))
# Send message to the email addresses listed in the copies
if email_copies:
email.body = admin_body
email.recipient = email_copies
email.send(fail_silently=True, attachments=attachments)
# Email copies to recipient list indicated in the form
if email_recipients:
email.body = admin_body
email.recipient = email_recipients
email.send(fail_silently=True, attachments=attachments)
# payment redirect
if (form.custom_payment
or form.recurring_payment) and entry.pricing:
# get the pricing's price, custom or otherwise
price = entry.pricing.price or form_for_form.cleaned_data.get(
'custom_price')
if form.recurring_payment:
if request.user.is_anonymous():
rp_user = entry.creator
else:
rp_user = request.user
billing_start_dt = datetime.datetime.now()
trial_period_start_dt = None
trial_period_end_dt = None
if entry.pricing.has_trial_period:
trial_period_start_dt = datetime.datetime.now()
trial_period_end_dt = trial_period_start_dt + datetime.timedelta(
1)
billing_start_dt = trial_period_end_dt
# Create recurring payment
rp = RecurringPayment(
user=rp_user,
description=form.title,
billing_period=entry.pricing.billing_period,
billing_start_dt=billing_start_dt,
num_days=entry.pricing.num_days,
due_sore=entry.pricing.due_sore,
payment_amount=price,
taxable=entry.pricing.taxable,
tax_rate=entry.pricing.tax_rate,
has_trial_period=entry.pricing.has_trial_period,
trial_period_start_dt=trial_period_start_dt,
trial_period_end_dt=trial_period_end_dt,
trial_amount=entry.pricing.trial_amount,
creator=rp_user,
creator_username=rp_user.username,
owner=rp_user,
owner_username=rp_user.username,
)
rp.save()
if rp.platform == 'authorizenet':
rp.add_customer_profile()
# redirect to recurring payments
messages.add_message(request, messages.SUCCESS,
_('Successful transaction.'))
return redirect('recurring_payment.view_account', rp.id,
rp.guid)
else:
# create the invoice
invoice = make_invoice_for_entry(entry, custom_price=price)
update_invoice_for_entry(invoice, billing_form)
# log an event for invoice add
EventLog.objects.log(instance=form)
# redirect to online payment
if (entry.payment_method.machine_name
).lower() == 'credit-card':
return redirect('payment.pay_online', invoice.id,
invoice.guid)
# redirect to invoice page
return redirect('invoice.view', invoice.id, invoice.guid)
# default redirect
form.completion_url = form.completion_url.strip(' ')
if form.completion_url:
return HttpResponseRedirect(form.completion_url)
return redirect("form_sent", form.slug)
# set form's template to forms/base.html if no template or template doesn't exist
if not form.template or not template_exists(form.template):
form.template = "forms/base.html"
context = {
"form": form,
'billing_form': billing_form,
"form_for_form": form_for_form,
'form_template': form.template,
}
return render_to_response(template, context, RequestContext(request))
def send_newsletter(self, newsletter_id, **kwargs):
from tendenci.apps.emails.models import Email
from tendenci.apps.newsletters.models import Newsletter, NewsletterRecurringData
from tendenci.apps.site_settings.utils import get_setting
from tendenci.apps.base.utils import validate_email
from tendenci.apps.newsletters.utils import get_newsletter_connection
connection = get_newsletter_connection()
if not connection:
print(
'Exiting..Please set up your newsletter email provider before proceeding.'
)
return
print("Started sending newsletter...")
if newsletter_id == 0:
raise CommandError(
'Newsletter ID is required. Usage: ./manage.py send_newsletter <newsletter_id>'
)
newsletter = Newsletter.objects.filter(pk=int(newsletter_id))
if newsletter.exists():
newsletter = newsletter[0]
else:
newsletter = None
if not newsletter:
raise CommandError(
'You are trying to send a newsletter that does not exist.')
# validate sender
if not validate_email(newsletter.email.sender):
raise CommandError(
'"{}" is not a valid sender email address.'.format(
newsletter.email.sender))
if newsletter.send_status == 'queued':
newsletter.send_status = 'sending'
elif newsletter.send_status == 'sent':
newsletter.send_status = 'resending'
elif newsletter.send_status == 'resent':
newsletter.send_status == 'resending'
newsletter.save()
if newsletter.schedule:
# save start_dt and status for the recurring
nr_data = NewsletterRecurringData(
newsletter=newsletter,
start_dt=datetime.datetime.now(),
send_status=newsletter.send_status)
nr_data.save()
newsletter.nr_data = nr_data
recipients = newsletter.get_recipients()
email = newsletter.email
# replace relative to absolute urls
self.site_url = get_setting('site', 'global', 'siteurl')
email.body = email.body.replace("src=\"/", "src=\"%s/" % self.site_url)
email.body = email.body.replace("href=\"/",
"href=\"%s/" % self.site_url)
if newsletter.group and newsletter.group.membership_types.all().exists(
):
membership_type = newsletter.group.membership_types.all()[0]
else:
membership_type = None
counter = 0
for recipient in recipients:
if hasattr(recipient.member, 'profile'):
profile = recipient.member.profile
else:
profile = None
# Skip if Don't Send Email is on
if newsletter.enforce_direct_mail_flag:
if profile and not profile.direct_mail:
continue
# skip if not a valid email address
if not validate_email(recipient.member.email):
continue
subject = email.subject
body = email.body
if '[firstname]' in subject:
subject = subject.replace('[firstname]',
recipient.member.first_name)
if '[lastname]' in subject:
subject = subject.replace('[lastname]',
recipient.member.last_name)
if '[username]' in body:
body = body.replace('[username]', recipient.member.username)
if '[firstname]' in body:
body = body.replace('[firstname]', recipient.member.first_name)
if '[unsubscribe_url]' in body:
#body = body.replace('[unsubscribe_url]', recipient.noninteractive_unsubscribe_url)
# The unsubscribe_url link should be something like <a href="[unsubscribe_url]">Unsubscribe</a>.
# But it can be messed up sometimes. Let's prevent that from happening.
p = r'(href=\")([^\"]*)(\[unsubscribe_url\])(\")'
body = re.sub(
p,
r'\1' + recipient.noninteractive_unsubscribe_url + r'\4',
body)
if '[browser_view_url]' in body:
body = body.replace('[browser_view_url]',
newsletter.get_browser_view_url())
if membership_type:
[membership] = recipient.member.membershipdefault_set.exclude(
status_detail='archive').order_by('-create_dt')[:1] or [
None
]
if membership:
# do find and replace
urls_dict = membership.get_common_urls()
for key in urls_dict.keys():
body = body.replace('[%s]' % key, urls_dict[key])
email_to_send = Email(subject=subject,
body=body,
sender=email.sender,
sender_display=email.sender_display,
reply_to=email.reply_to,
recipient=recipient.member.email)
print(u"Sending to {}".format(str(recipient.member.email)))
email_to_send.send(connection=connection)
counter += 1
print(u"Newsletter sent to {}".format(str(recipient.member.email)))
if newsletter.send_to_email2 and hasattr(recipient.member, 'profile') \
and validate_email(recipient.member.profile.email2):
email_to_send.recipient = recipient.member.profile.email2
email_to_send.send(connection=connection)
counter += 1
print(u"Newsletter sent to {}".format(
str(recipient.member.profile.email2)))
if newsletter.send_status == 'sending':
newsletter.send_status = 'sent'
newsletter.date_email_sent = datetime.datetime.now()
elif newsletter.send_status == 'resending':
newsletter.send_status = 'resent'
newsletter.date_last_resent = datetime.datetime.now()
if not newsletter.resend_count:
newsletter.resend_count = 0
newsletter.resend_count += 1
newsletter.email_sent_count = counter
newsletter.save()
if newsletter.nr_data:
# save the finish_dt and email_sent_count for the recurring
newsletter.nr_data.finish_dt = datetime.datetime.now()
newsletter.nr_data.email_sent_count = newsletter.email_sent_count
newsletter.nr_data.send_status = newsletter.send_status
newsletter.nr_data.save()
print("Successfully sent %s newsletter emails." % counter)
print("Sending confirmation message to creator...")
# send confirmation email
subject = "Newsletter Submission Recap for %s" % newsletter.email.subject
detail_url = get_setting('site', 'global',
'siteurl') + newsletter.get_absolute_url()
params = {
'first_name': newsletter.email.creator.first_name,
'subject': newsletter.email.subject,
'count': counter,
'detail_url': detail_url
}
body = render_to_string(
template_name='newsletters/newsletter_sent_email_body.html',
context=params)
email = Email(recipient=newsletter.email.sender,
subject=subject,
body=body)
email.send(connection=connection)
print("Confirmation email sent.")
# add cache clear to resolve issue
# TODO: cache clear only to specifies
cache.clear()
print('Cache cleared!')
def send_newsletter(self, newsletter_id, **kwargs):
from tendenci.apps.emails.models import Email
from tendenci.apps.newsletters.models import Newsletter
from tendenci.apps.site_settings.utils import get_setting
from tendenci.apps.base.utils import validate_email
from tendenci.apps.newsletters.utils import get_newsletter_connection
connection = get_newsletter_connection()
if not connection:
print('Exiting..Please set up your newsletter email provider before proceeding.')
return
print("Started sending newsletter...")
if newsletter_id == 0:
raise CommandError('Newsletter ID is required. Usage: ./manage.py send_newsletter <newsletter_id>')
newsletter = Newsletter.objects.filter(pk=int(newsletter_id))
if newsletter.exists():
newsletter = newsletter[0]
else:
newsletter = None
if not newsletter:
raise CommandError('You are trying to send a newsletter that does not exist.')
if newsletter.send_status == 'queued':
newsletter.send_status = 'sending'
elif newsletter.send_status == 'sent':
newsletter.send_status = 'resending'
elif newsletter.send_status == 'resent':
newsletter.send_status == 'resending'
newsletter.save()
recipients = newsletter.get_recipients()
email = newsletter.email
# replace relative to absolute urls
self.site_url = get_setting('site', 'global', 'siteurl')
email.body = email.body.replace("src=\"/", "src=\"%s/" % self.site_url)
email.body = email.body.replace("href=\"/", "href=\"%s/" % self.site_url)
counter = 0
for recipient in recipients:
# skip if not a valid email address
if not validate_email(recipient.member.email):
continue
subject = email.subject
body = email.body
if '[firstname]' in subject:
subject = subject.replace('[firstname]', recipient.member.first_name)
if '[lastname]' in subject:
subject = subject.replace('[lastname]', recipient.member.last_name)
if '[username]' in body:
body = body.replace('[username]', recipient.member.username)
if '[firstname]' in body:
body = body.replace('[firstname]', recipient.member.first_name)
if '[unsubscribe_url]' in body:
#body = body.replace('[unsubscribe_url]', recipient.noninteractive_unsubscribe_url)
# The unsubscribe_url link should be something like <a href="[unsubscribe_url]">Unsubscribe</a>.
# But it can be messed up sometimes. Let's prevent that from happening.
p = r'(href=\")([^\"]*)(\[unsubscribe_url\])(\")'
body = re.sub(p, r'\1' + recipient.noninteractive_unsubscribe_url + r'\4', body)
if '[browser_view_url]' in body:
body = body.replace('[browser_view_url]', newsletter.get_browser_view_url())
email_to_send = Email(
subject=subject,
body=body,
sender=email.sender,
sender_display=email.sender_display,
reply_to=email.reply_to,
recipient=recipient.member.email
)
print(u"Sending to {}".format(unicode(recipient.member.email)))
email_to_send.send(connection=connection)
counter += 1
print(u"Newsletter sent to {}".format(unicode(recipient.member.email)))
if newsletter.send_to_email2 and hasattr(recipient.member, 'profile') \
and validate_email(recipient.member.profile.email2):
email_to_send.recipient = recipient.member.profile.email2
email_to_send.send(connection=connection)
counter += 1
print(u"Newsletter sent to {}".format(unicode(recipient.member.profile.email2)))
if newsletter.send_status == 'sending':
newsletter.send_status = 'sent'
newsletter.date_email_sent = datetime.datetime.now()
elif newsletter.send_status == 'resending':
newsletter.send_status = 'resent'
newsletter.date_last_resent = datetime.datetime.now()
if not newsletter.resend_count:
newsletter.resend_count = 0
newsletter.resend_count += 1
newsletter.email_sent_count = counter
newsletter.save()
print("Successfully sent %s newsletter emails." % counter)
print("Sending confirmation message to creator...")
# send confirmation email
subject = "Newsletter Submission Recap for %s" % newsletter.email.subject
detail_url = get_setting('site', 'global', 'siteurl') + newsletter.get_absolute_url()
params = {'first_name': newsletter.email.creator.first_name,
'subject': newsletter.email.subject,
'count': counter,
'detail_url': detail_url}
body = render_to_string(
'newsletters/newsletter_sent_email_body.html', params)
email = Email(
recipient=newsletter.email.sender,
subject=subject,
body=body)
email.send(connection=connection)
print("Confirmation email sent.")
# add cache clear to resolve issue
# TODO: cache clear only to specifies
cache.clear()
print('Cache cleared!')
def form_detail(request, slug, template="forms/form_detail.html"):
"""
Display a built form and handle submission.
"""
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=slug)
if not has_view_perm(request.user,'forms.view_form',form):
raise Http403
# If form has a recurring payment, make sure the user is logged in
if form.recurring_payment:
[email_field] = form.fields.filter(field_type__iexact='EmailVerificationField')[:1] or [None]
if request.user.is_anonymous and not email_field:
# anonymous user - if we don't have the email field, redirect to login
response = redirect('auth_login')
response['Location'] += '?next=%s' % form.get_absolute_url()
return response
if request.user.is_superuser and not email_field:
messages.add_message(request, messages.WARNING,
'Please edit the form to include an email field ' +
'as it is required for setting up a recurring ' +
'payment for anonymous users.')
form_for_form = FormForForm(form, request.user, request.POST or None, request.FILES or None)
if form.custom_payment and not form.recurring_payment:
billing_form = BillingForm(request.POST or None)
if request.user.is_authenticated:
billing_form.initial = {
'first_name':request.user.first_name,
'last_name':request.user.last_name,
'email':request.user.email}
else:
billing_form = None
for field in form_for_form.fields:
field_default = request.GET.get(field, None)
if field_default:
form_for_form.fields[field].initial = field_default
if request.method == "POST":
if form_for_form.is_valid() and (not billing_form or billing_form.is_valid()):
entry = form_for_form.save()
entry.entry_path = request.POST.get("entry_path", "")
if request.user.is_anonymous:
if entry.get_email_address():
emailfield = entry.get_email_address()
firstnamefield = entry.get_first_name()
lastnamefield = entry.get_last_name()
phonefield = entry.get_phone_number()
password = ''
for i in range(0, 10):
password += random.choice(string.ascii_lowercase + string.ascii_uppercase)
user_list = User.objects.filter(email=emailfield).order_by('-last_login')
if user_list:
anonymous_creator = user_list[0]
else:
anonymous_creator = User(username=emailfield[:30], email=emailfield,
first_name=firstnamefield, last_name=lastnamefield)
anonymous_creator.set_password(password)
anonymous_creator.is_active = False
anonymous_creator.save()
anonymous_profile = Profile(user=anonymous_creator, owner=anonymous_creator,
creator=anonymous_creator, phone=phonefield)
anonymous_profile.save()
entry.creator = anonymous_creator
else:
entry.creator = request.user
entry.save()
entry.set_group_subscribers()
# Email
subject = generate_email_subject(form, entry)
email_headers = {} # content type specified below
if form.email_from:
email_headers.update({'Reply-To':form.email_from})
# Email to submitter
# fields aren't included in submitter body to prevent spam
submitter_body = generate_submitter_email_body(entry, form_for_form)
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form_for_form.email_to()
is_spam = Email.is_blocked(email_to)
if is_spam:
# log the spam
description = "Email \"{0}\" blocked because it is listed in email_blocks.".format(email_to)
EventLog.objects.log(instance=form, description=description)
if form.completion_url:
return HttpResponseRedirect(form.completion_url)
return redirect("form_sent", form.slug)
email = Email()
email.subject = subject
email.reply_to = form.email_from
if email_to and form.send_email and form.email_text:
# Send message to the person who submitted the form.
email.recipient = email_to
email.body = submitter_body
email.send(fail_silently=True)
# Email copies to admin
admin_body = generate_admin_email_body(entry, form_for_form)
email_from = email_to or email_from # Send from the email entered.
email_headers = {} # Reset the email_headers
email_headers.update({'Reply-To':email_from})
email_copies = [e.strip() for e in form.email_copies.split(',') if e.strip()]
subject = subject.encode(errors='ignore')
email_recipients = entry.get_function_email_recipients()
# reply_to of admin emails goes to submitter
email.reply_to = email_to
if email_copies or email_recipients:
# prepare attachments
attachments = []
try:
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
except ValueError:
attachments = []
for field_entry in entry.fields.all():
if field_entry.field.field_type == 'FileField':
try:
f = default_storage.open(field_entry.value)
except IOError:
pass
else:
f.seek(0)
attachments.append((f.name.split('/')[-1], f.read()))
# Send message to the email addresses listed in the copies
if email_copies:
email.body = admin_body
email.recipient = email_copies
email.send(fail_silently=True, attachments=attachments)
# Email copies to recipient list indicated in the form
if email_recipients:
email.body = admin_body
email.recipient = email_recipients
email.send(fail_silently=True, attachments=attachments)
# payment redirect
if (form.custom_payment or form.recurring_payment) and entry.pricing:
# get the pricing's price, custom or otherwise
price = entry.pricing.price or form_for_form.cleaned_data.get('custom_price')
if form.recurring_payment:
if request.user.is_anonymous:
rp_user = entry.creator
else:
rp_user = request.user
billing_start_dt = datetime.datetime.now()
trial_period_start_dt = None
trial_period_end_dt = None
if entry.pricing.has_trial_period:
trial_period_start_dt = datetime.datetime.now()
trial_period_end_dt = trial_period_start_dt + datetime.timedelta(1)
billing_start_dt = trial_period_end_dt
# Create recurring payment
rp = RecurringPayment(
user=rp_user,
description=form.title,
billing_period=entry.pricing.billing_period,
billing_start_dt=billing_start_dt,
num_days=entry.pricing.num_days,
due_sore=entry.pricing.due_sore,
payment_amount=price,
taxable=entry.pricing.taxable,
tax_rate=entry.pricing.tax_rate,
has_trial_period=entry.pricing.has_trial_period,
trial_period_start_dt=trial_period_start_dt,
trial_period_end_dt=trial_period_end_dt,
trial_amount=entry.pricing.trial_amount,
creator=rp_user,
creator_username=rp_user.username,
owner=rp_user,
owner_username=rp_user.username,
)
rp.save()
if rp.platform == 'authorizenet':
rp.add_customer_profile()
# redirect to recurring payments
messages.add_message(request, messages.SUCCESS, _('Successful transaction.'))
return redirect('recurring_payment.view_account', rp.id, rp.guid)
else:
# create the invoice
invoice = make_invoice_for_entry(entry, custom_price=price)
update_invoice_for_entry(invoice, billing_form)
# log an event for invoice add
EventLog.objects.log(instance=form)
# redirect to online payment
if (entry.payment_method.machine_name).lower() == 'credit-card':
return redirect('payment.pay_online', invoice.id, invoice.guid)
# redirect to invoice page
return redirect('invoice.view', invoice.id, invoice.guid)
# default redirect
if form.completion_url:
return HttpResponseRedirect(form.completion_url.strip())
return redirect("form_sent", form.slug)
# set form's template to forms/base.html if no template or template doesn't exist
if not form.template or not template_exists(form.template):
form.template = "forms/base.html"
context = {
"form": form,
'billing_form': billing_form,
"form_for_form": form_for_form,
'form_template': form.template,
}
return render_to_resp(request=request, template_name=template, context=context)
def message(request, group_slug, template_name='user_groups/message.html'):
"""
Send a message to the group
"""
from tendenci.apps.emails.models import Email
from django.core.mail import send_mail
from django.core.mail import EmailMessage
group = get_object_or_404(Group, slug=group_slug)
EventLog.objects.log(instance=group)
members = GroupMembership.objects.filter(group=group,
status=True,
status_detail='active')
num_members = members.count()
form = MessageForm(request.POST or None,
request=request,
num_members=num_members)
if request.method == 'POST' and form.is_valid():
email = Email()
email.sender_display = request.user.get_full_name()
email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email.reply_to = email.sender
email.content_type = email.CONTENT_TYPE_HTML
email.subject = form.cleaned_data['subject']
email.body = form.cleaned_data['body']
email.save(request.user)
# send email to myself (testing email)
if form.cleaned_data['is_test']:
email.recipient = request.user.email
print(email.recipient)
email.send()
messages.add_message(request, messages.SUCCESS,
_('Successfully sent test email to yourself'))
EventLog.objects.log(instance=email)
else:
#api_url = settings.MAILCHIMP_API_URL + '/campaigns/'
#api_key = settings.MAILCHIMP_API_KEY
#headers = {'Content-Type': 'application/json', 'Authorization': api_key}
#response = requests.get(api_url, headers=headers);
#jsonInput = json.loads(response.text);
#list_results = [[x['id'], x['name']] for x in jsonInput['lists']]
# print(list_results)
#body_content = {"plain_text": "Hi There,\r\nThis is a test again.\r\n-Blake B\n==============================================\n\n"}
msg = EmailMessage('Request Callback',
'Here is the message.',
to=['*****@*****.**'])
msg.send()
#send email to members
for member in members:
email.recipient = member.member.email
print(email.recipient)
#try:
#test = send_mail(
# 'Subject here',
# 'Here is the message.',
# ['*****@*****.**'],
# fail_silently=False,
#)
#print(test)
#except SMTPException as e:
#print('%s (%s)' % (e.message, type(e)))
#email.send()
messages.add_message(
request, messages.SUCCESS,
_('Successfully sent email to all %(num)s members in this group'
% {'num': num_members}))
EventLog.objects.log(instance=email)
return redirect('group.detail', group_slug=group_slug)
else:
print('form errors', form.errors.items())
return render(request, template_name, {
'group': group,
'num_members': num_members,
'form': form
})
def handle(self, *args, **options):
import datetime
from tendenci.apps.emails.models import Email
from tendenci.apps.newsletters.models import Newsletter
from tendenci.apps.site_settings.utils import get_setting
from tendenci.apps.newsletters.utils import get_newsletter_connection
connection = get_newsletter_connection()
if not connection:
print('Exiting..Please set up your newsletter email provider before proceeding.')
return
print "Started sending newsletter..."
newsletter_id = options['newsletter_id']
if newsletter_id == 0:
raise CommandError('Newsletter ID is required. Usage: ./manage.py send_newsletter <newsletter_id>')
newsletter = Newsletter.objects.filter(pk=int(newsletter_id))
if newsletter.exists():
newsletter = newsletter[0]
else:
newsletter = None
if not newsletter:
raise CommandError('You are trying to send a newsletter that does not exist.')
if newsletter.send_status == 'queued':
newsletter.send_status = 'sending'
elif newsletter.send_status == 'sent':
newsletter.send_status = 'resending'
elif newsletter.send_status == 'resent':
newsletter.send_status == 'resending'
newsletter.save()
recipients = newsletter.get_recipients()
email = newsletter.email
# replace relative to absolute urls
self.site_url = get_setting('site', 'global', 'siteurl')
email.body = email.body.replace("src=\"/", "src=\"%s/" % self.site_url)
email.body = email.body.replace("href=\"/", "href=\"%s/" % self.site_url)
counter = 0
for recipient in recipients:
subject = email.subject
body = email.body
if '[firstname]' in subject:
subject = subject.replace('[firstname]', recipient.member.first_name)
if '[lastname]' in subject:
subject = subject.replace('[lastname]', recipient.member.last_name)
if '[username]' in body:
body = body.replace('[username]', recipient.member.username)
if '[firstname]' in body:
body = body.replace('[firstname]', recipient.member.first_name)
if '[unsubscribe_url]' in body:
body = body.replace('[unsubscribe_url]', recipient.noninteractive_unsubscribe_url)
if '[browser_view_url]' in body:
body = body.replace('[browser_view_url]', newsletter.get_browser_view_url())
email_to_send = Email(
subject=subject,
body=body,
sender=email.sender,
sender_display=email.sender_display,
reply_to=email.reply_to,
recipient=recipient.member.email
)
email_to_send.send(connection=connection)
counter += 1
print "Newsletter sent to %s" % recipient.member.email
if newsletter.send_to_email2 and hasattr(recipient.member, 'profile') \
and recipient.member.profile.email2:
email_to_send.recipient = recipient.member.profile.email2
email_to_send.send(connection=connection)
counter += 1
print "Newsletter sent to %s" % recipient.member.profile.email2
if newsletter.send_status == 'sending':
newsletter.send_status = 'sent'
newsletter.date_email_sent = datetime.datetime.now()
elif newsletter.send_status == 'resending':
newsletter.send_status = 'resent'
newsletter.date_last_resent = datetime.datetime.now()
if not newsletter.resend_count:
newsletter.resend_count = 0
newsletter.resend_count += 1
newsletter.email_sent_count = counter
newsletter.save()
print "Successfully sent %s newsletter emails." % counter
print "Sending confirmation message to creator..."
# send confirmation email
subject = "Newsletter Submission Recap for %s" % newsletter.email.subject
detail_url = get_setting('site', 'global', 'siteurl') + newsletter.get_absolute_url()
params = {'first_name': newsletter.email.creator.first_name,
'subject': newsletter.email.subject,
'count': counter,
'detail_url': detail_url}
body = render_to_string(
'newsletters/newsletter_sent_email_body.html', params)
email = Email(
recipient=newsletter.email.sender,
subject=subject,
body=body)
email.send(connection=connection)
print "Confirmation email sent."
# add cache clear to resolve issue
# TODO: cache clear only to specifies
cache.clear()
print 'Cache cleared!'
def send_newsletter(self, newsletter_id, **kwargs):
from tendenci.apps.emails.models import Email
from tendenci.apps.newsletters.models import Newsletter
from tendenci.apps.site_settings.utils import get_setting
from tendenci.apps.newsletters.utils import get_newsletter_connection
connection = get_newsletter_connection()
if not connection:
print(
'Exiting..Please set up your newsletter email provider before proceeding.'
)
return
print "Started sending newsletter..."
if newsletter_id == 0:
raise CommandError(
'Newsletter ID is required. Usage: ./manage.py send_newsletter <newsletter_id>'
)
newsletter = Newsletter.objects.filter(pk=int(newsletter_id))
if newsletter.exists():
newsletter = newsletter[0]
else:
newsletter = None
if not newsletter:
raise CommandError(
'You are trying to send a newsletter that does not exist.')
if newsletter.send_status == 'queued':
newsletter.send_status = 'sending'
elif newsletter.send_status == 'sent':
newsletter.send_status = 'resending'
elif newsletter.send_status == 'resent':
newsletter.send_status == 'resending'
newsletter.save()
recipients = newsletter.get_recipients()
email = newsletter.email
# replace relative to absolute urls
self.site_url = get_setting('site', 'global', 'siteurl')
email.body = email.body.replace("src=\"/", "src=\"%s/" % self.site_url)
email.body = email.body.replace("href=\"/",
"href=\"%s/" % self.site_url)
counter = 0
for recipient in recipients:
subject = email.subject
body = email.body
if '[firstname]' in subject:
subject = subject.replace('[firstname]',
recipient.member.first_name)
if '[lastname]' in subject:
subject = subject.replace('[lastname]',
recipient.member.last_name)
if '[username]' in body:
body = body.replace('[username]', recipient.member.username)
if '[firstname]' in body:
body = body.replace('[firstname]', recipient.member.first_name)
if '[unsubscribe_url]' in body:
body = body.replace('[unsubscribe_url]',
recipient.noninteractive_unsubscribe_url)
if '[browser_view_url]' in body:
body = body.replace('[browser_view_url]',
newsletter.get_browser_view_url())
email_to_send = Email(subject=subject,
body=body,
sender=email.sender,
sender_display=email.sender_display,
reply_to=email.reply_to,
recipient=recipient.member.email)
email_to_send.send(connection=connection)
counter += 1
print "Newsletter sent to %s" % recipient.member.email
if newsletter.send_to_email2 and hasattr(recipient.member, 'profile') \
and recipient.member.profile.email2:
email_to_send.recipient = recipient.member.profile.email2
email_to_send.send(connection=connection)
counter += 1
print "Newsletter sent to %s" % recipient.member.profile.email2
if newsletter.send_status == 'sending':
newsletter.send_status = 'sent'
newsletter.date_email_sent = datetime.datetime.now()
elif newsletter.send_status == 'resending':
newsletter.send_status = 'resent'
newsletter.date_last_resent = datetime.datetime.now()
if not newsletter.resend_count:
newsletter.resend_count = 0
newsletter.resend_count += 1
newsletter.email_sent_count = counter
newsletter.save()
print "Successfully sent %s newsletter emails." % counter
print "Sending confirmation message to creator..."
# send confirmation email
subject = "Newsletter Submission Recap for %s" % newsletter.email.subject
detail_url = get_setting('site', 'global',
'siteurl') + newsletter.get_absolute_url()
params = {
'first_name': newsletter.email.creator.first_name,
'subject': newsletter.email.subject,
'count': counter,
'detail_url': detail_url
}
body = render_to_string('newsletters/newsletter_sent_email_body.html',
params)
email = Email(recipient=newsletter.email.sender,
subject=subject,
body=body)
email.send(connection=connection)
print "Confirmation email sent."
# add cache clear to resolve issue
# TODO: cache clear only to specifies
cache.clear()
print 'Cache cleared!'
def message(request, group_slug, template_name='user_groups/message.html'):
"""
Send a message to the group
"""
from tendenci.apps.emails.models import Email
group = get_object_or_404(Group, slug=group_slug)
EventLog.objects.log(instance=group)
members = GroupMembership.objects.filter(group=group,
status=True,
status_detail='active')
num_members = members.count()
form = MessageForm(request.POST or None,
request=request,
num_members=num_members)
if request.method == 'POST' and form.is_valid():
email = Email()
email.sender_display = request.user.get_full_name()
email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email.reply_to = email.sender
email.content_type = email.CONTENT_TYPE_HTML
email.subject = form.cleaned_data['subject']
email.body = form.cleaned_data['body']
email.save(request.user)
# send email to myself (testing email)
if form.cleaned_data['is_test']:
email.recipient = request.user.email
email.send()
messages.add_message(request, messages.SUCCESS,
_('Successfully sent test email to yourself'))
EventLog.objects.log(instance=email)
else:
# send email to members
for member in members:
email.recipient = member.member.email
email.send()
messages.add_message(
request, messages.SUCCESS,
_('Successfully sent email to all %(num)s members in this group'
% {'num': num_members}))
EventLog.objects.log(instance=email)
return redirect('group.detail', group_slug=group_slug)
else:
print('form errors', list(form.errors.items()))
return render_to_resp(request=request,
template_name=template_name,
context={
'group': group,
'num_members': num_members,
'form': form
})
def message(request, group_slug, template_name='user_groups/message.html'):
"""
Send a message to the group
"""
from tendenci.apps.emails.models import Email
group = get_object_or_404(Group, slug=group_slug)
EventLog.objects.log(instance=group)
members = GroupMembership.objects.filter(
group=group,
status=True,
status_detail='active')
num_members = members.count()
form = MessageForm(request.POST or None,
request=request,
num_members=num_members)
if request.method == 'POST' and form.is_valid():
email = Email()
email.sender_display = request.user.get_full_name()
email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email.reply_to = email.sender
email.content_type = 'text/html'
email.subject = form.cleaned_data['subject']
email.body = form.cleaned_data['body']
email.save(request.user)
# send email to myself (testing email)
if form.cleaned_data['is_test']:
email.recipient = request.user.email
email.send()
messages.add_message(
request,
messages.SUCCESS,
_('Successfully sent test email to yourself'))
EventLog.objects.log(instance=email)
else:
# send email to members
for member in members:
email.recipient = member.member.email
email.send()
messages.add_message(
request,
messages.SUCCESS,
_('Successfully sent email to all %(num)s members in this group' % {'num': num_members}))
EventLog.objects.log(instance=email)
return redirect('group.detail', group_slug=group_slug)
else:
print 'form errors', form.errors.items()
return render(request, template_name, {
'group': group,
'num_members': num_members,
'form': form})
def message(request, group_slug, template_name='user_groups/message.html'):
"""
Send a message to the group
"""
from tendenci.apps.emails.models import Email
group = get_object_or_404(Group, slug=group_slug)
if group.membership_types.all().exists():
membership_type = group.membership_types.all()[0]
else:
membership_type = None
EventLog.objects.log(instance=group)
members = GroupMembership.objects.filter(group=group,
status=True,
status_detail='active')
num_members = members.count()
form = MessageForm(request.POST or None,
request=request,
num_members=num_members)
if request.method == 'POST' and form.is_valid():
email = Email()
email.sender_display = request.user.get_full_name()
email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email.reply_to = email.sender
email.content_type = email.CONTENT_TYPE_HTML
email.subject = form.cleaned_data['subject']
email.body = form.cleaned_data['body']
email.save(request.user)
# send email to myself (testing email)
if form.cleaned_data['is_test']:
email.recipient = request.user.email
email.send()
messages.add_message(request, messages.SUCCESS,
_('Successfully sent test email to yourself'))
EventLog.objects.log(instance=email)
else:
# send email to members
for member in members:
original_body = email.body
email.recipient = member.member.email
if membership_type:
[membership] = member.member.membershipdefault_set.exclude(
status_detail='archive').order_by(
'-create_dt')[:1] or [None]
if membership:
# do find and replace
urls_dict = membership.get_common_urls()
for key in urls_dict.keys():
email.body = email.body.replace(
'[%s]' % key, urls_dict[key])
email.send()
# restore back to the original
email.body = original_body
messages.add_message(
request, messages.SUCCESS,
_('Successfully sent email to all %(num)s members in this group'
% {'num': num_members}))
EventLog.objects.log(instance=email)
return redirect('group.detail', group_slug=group_slug)
else:
print('form errors', list(form.errors.items()))
if membership_type:
available_tokens = '[membership_link], [membership_type], [directory_url], [directory_edit_url], [invoice_link]'
else:
available_tokens = ''
return render_to_resp(request=request,
template_name=template_name,
context={
'group': group,
'num_members': num_members,
'membership_type': membership_type,
'available_tokens': available_tokens,
'form': form
})
def form_detail(request, slug, template="forms/form_detail.html"):
"""
Display a built form and handle submission.
"""
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=slug)
if not has_view_perm(request.user, 'forms.view_form', form):
raise Http403
# If form has a recurring payment, make sure the user is logged in
if form.recurring_payment:
[email_field] = form.fields.filter(
field_type__iexact='EmailVerificationField')[:1] or [None]
if request.user.is_anonymous and not email_field:
# anonymous user - if we don't have the email field, redirect to login
response = redirect('auth_login')
response['Location'] += '?next=%s' % form.get_absolute_url()
return response
if request.user.is_superuser and not email_field:
messages.add_message(
request, messages.WARNING,
'Please edit the form to include an email field ' +
'as it is required for setting up a recurring ' +
'payment for anonymous users.')
if form.custom_payment and not form.recurring_payment:
billing_form = BillingForm(request.POST or None)
if request.user.is_authenticated:
billing_form.initial = {
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'email': request.user.email
}
else:
billing_form = None
form_for_form = FormForForm(form, request.user, request.session,
request.POST or None, request.FILES or None)
if get_setting('site', 'global', 'captcha'): # add captcha
if billing_form:
# append the captcha to the end of the billing form
captcha_field = CustomCatpchaField(label=_('Type the code below'))
if 'captcha' in form_for_form.fields:
form_for_form.fields.pop('captcha')
billing_form.fields['captcha'] = captcha_field
for field in form_for_form.fields:
field_default = request.GET.get(field, None)
if field_default:
form_for_form.fields[field].initial = field_default
if request.method == "POST":
if form_for_form.is_valid() and (not billing_form
or billing_form.is_valid()):
entry = form_for_form.save()
entry.entry_path = request.POST.get("entry_path", "")
if request.user.is_anonymous:
entry.creator = entry.check_and_create_user()
else:
entry.creator = request.user
entry.save()
entry.set_group_subscribers()
# Email
subject = generate_email_subject(form, entry)
email_headers = {} # content type specified below
if form.email_from:
email_headers.update({'Reply-To': form.email_from})
# Email to submitter
# fields aren't included in submitter body to prevent spam
submitter_body = generate_submitter_email_body(
entry, form_for_form)
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form_for_form.email_to()
is_spam = Email.is_blocked(email_to)
if is_spam:
# log the spam
description = "Email \"{0}\" blocked because it is listed in email_blocks.".format(
email_to)
EventLog.objects.log(instance=form, description=description)
if form.completion_url:
return HttpResponseRedirect(form.completion_url)
return redirect("form_sent", form.slug)
email = Email()
email.subject = subject
email.reply_to = form.email_from
if email_to and form.send_email and form.email_text:
# Send message to the person who submitted the form.
email.recipient = email_to
email.body = submitter_body
email.send(fail_silently=getattr(settings,
'EMAIL_FAIL_SILENTLY', True))
# log an event
EventLog.objects.log(
instance=form,
description='Confirmation email sent to {}'.format(
email_to))
# Email copies to admin
admin_body = generate_admin_email_body(entry,
form_for_form,
user=request.user)
email_from = email_to or email_from # Send from the email entered.
email_headers = {} # Reset the email_headers
email_headers.update({'Reply-To': email_from})
email_copies = [
e.strip() for e in form.email_copies.split(',') if e.strip()
]
subject = subject.encode(errors='ignore')
email_recipients = entry.get_function_email_recipients()
# reply_to of admin emails goes to submitter
email.reply_to = email_to
if email_copies or email_recipients:
# prepare attachments
attachments = []
# Commenting out the attachment block to not add attachments to the email for the reason below:
# According to SES message quotas https://docs.aws.amazon.com/ses/latest/DeveloperGuide/quotas.html,
# the maximum message size (including attachments) is 10 MB per message (after base64 encoding)
# which means the actual size should be less than 7.5 MB or so because text after encoded with the BASE64
# algorithm increases its size by 1/3. But the allowed upload size is much larger than 7.5 MB.
# try:
# for f in form_for_form.files.values():
# f.seek(0)
# attachments.append((f.name, f.read()))
# except ValueError:
# attachments = []
# for field_entry in entry.fields.all():
# if field_entry.field.field_type == 'FileField':
# try:
# f = default_storage.open(field_entry.value)
# except IOError:
# pass
# else:
# f.seek(0)
# attachments.append((f.name.split('/')[-1], f.read()))
fail_silently = getattr(settings, 'EMAIL_FAIL_SILENTLY', True)
# Send message to the email addresses listed in the copies
if email_copies:
email.body = admin_body
email.recipient = email_copies
# if request.user.is_anonymous or not request.user.is_active:
# email.content_type = 'text'
email.send(fail_silently=fail_silently,
attachments=attachments)
# Email copies to recipient list indicated in the form
if email_recipients:
email.body = admin_body
email.recipient = email_recipients
email.send(fail_silently=fail_silently,
attachments=attachments)
# payment redirect
if (form.custom_payment
or form.recurring_payment) and entry.pricing:
# get the pricing's price, custom or otherwise
price = entry.pricing.price or form_for_form.cleaned_data.get(
'custom_price')
if form.recurring_payment:
if request.user.is_anonymous:
rp_user = entry.creator
else:
rp_user = request.user
billing_start_dt = datetime.datetime.now()
trial_period_start_dt = None
trial_period_end_dt = None
if entry.pricing.has_trial_period:
trial_period_start_dt = datetime.datetime.now()
trial_period_end_dt = trial_period_start_dt + datetime.timedelta(
1)
billing_start_dt = trial_period_end_dt
# Create recurring payment
rp = RecurringPayment(
user=rp_user,
description=form.title,
billing_period=entry.pricing.billing_period,
billing_start_dt=billing_start_dt,
num_days=entry.pricing.num_days,
due_sore=entry.pricing.due_sore,
payment_amount=price,
taxable=entry.pricing.taxable,
tax_rate=entry.pricing.tax_rate,
has_trial_period=entry.pricing.has_trial_period,
trial_period_start_dt=trial_period_start_dt,
trial_period_end_dt=trial_period_end_dt,
trial_amount=entry.pricing.trial_amount,
creator=rp_user,
creator_username=rp_user.username,
owner=rp_user,
owner_username=rp_user.username,
)
rp.save()
if rp.platform == 'authorizenet':
rp.add_customer_profile()
# redirect to recurring payments
messages.add_message(request, messages.SUCCESS,
_('Successful transaction.'))
return redirect('recurring_payment.view_account', rp.id,
rp.guid)
else:
# create the invoice
invoice = make_invoice_for_entry(entry, custom_price=price)
update_invoice_for_entry(invoice, billing_form)
# log an event for invoice add
EventLog.objects.log(instance=form)
# redirect to online payment
if invoice.balance > 0:
if (entry.payment_method.machine_name
).lower() == 'credit-card':
return redirect('payment.pay_online', invoice.id,
invoice.guid)
# redirect to invoice page
return redirect('invoice.view', invoice.id,
invoice.guid)
# default redirect
if form.completion_url:
completion_url = form.completion_url.strip().replace(
'[entry_id]', str(entry.id))
return HttpResponseRedirect(completion_url)
return redirect("form_sent", form.slug)
# set form's template to forms/base.html if no template or template doesn't exist
if not form.template or not template_exists(form.template):
form.template = "forms/base.html"
context = {
"form": form,
'billing_form': billing_form,
"form_for_form": form_for_form,
'form_template': form.template,
}
return render_to_resp(request=request,
template_name=template,
context=context)
def send_newsletter(self, newsletter_id, **kwargs):
from tendenci.apps.emails.models import Email
from tendenci.apps.newsletters.models import Newsletter
from tendenci.apps.site_settings.utils import get_setting
from tendenci.apps.base.utils import validate_email
from tendenci.apps.newsletters.utils import get_newsletter_connection
connection = get_newsletter_connection()
if not connection:
print(
'Exiting..Please set up your newsletter email provider before proceeding.'
)
return
print("Started sending newsletter...")
if newsletter_id == 0:
raise CommandError(
'Newsletter ID is required. Usage: ./manage.py send_newsletter <newsletter_id>'
)
newsletter = Newsletter.objects.filter(pk=int(newsletter_id))
if newsletter.exists():
newsletter = newsletter[0]
else:
newsletter = None
if not newsletter:
raise CommandError(
'You are trying to send a newsletter that does not exist.')
if newsletter.send_status == 'queued':
newsletter.send_status = 'sending'
elif newsletter.send_status == 'sent':
newsletter.send_status = 'resending'
elif newsletter.send_status == 'resent':
newsletter.send_status == 'resending'
newsletter.save()
recipients = newsletter.get_recipients()
email = newsletter.email
# replace relative to absolute urls
self.site_url = get_setting('site', 'global', 'siteurl')
email.body = email.body.replace("src=\"/", "src=\"%s/" % self.site_url)
email.body = email.body.replace("href=\"/",
"href=\"%s/" % self.site_url)
counter = 0
for recipient in recipients:
# skip if not a valid email address
if not validate_email(recipient.member.email):
continue
subject = email.subject
body = email.body
if '[firstname]' in subject:
subject = subject.replace('[firstname]',
recipient.member.first_name)
if '[lastname]' in subject:
subject = subject.replace('[lastname]',
recipient.member.last_name)
if '[username]' in body:
body = body.replace('[username]', recipient.member.username)
if '[firstname]' in body:
body = body.replace('[firstname]', recipient.member.first_name)
if '[unsubscribe_url]' in body:
#body = body.replace('[unsubscribe_url]', recipient.noninteractive_unsubscribe_url)
# The unsubscribe_url link should be something like <a href="[unsubscribe_url]">Unsubscribe</a>.
# But it can be messed up sometimes. Let's prevent that from happening.
p = r'(href=\")([^\"]*)(\[unsubscribe_url\])(\")'
body = re.sub(
p,
r'\1' + recipient.noninteractive_unsubscribe_url + r'\4',
body)
if '[browser_view_url]' in body:
body = body.replace('[browser_view_url]',
newsletter.get_browser_view_url())
email_to_send = Email(subject=subject,
body=body,
sender=email.sender,
sender_display=email.sender_display,
reply_to=email.reply_to,
recipient=recipient.member.email)
print(u"Sending to {}".format(str(recipient.member.email)))
email_to_send.send(connection=connection)
counter += 1
print(u"Newsletter sent to {}".format(str(recipient.member.email)))
if newsletter.send_to_email2 and hasattr(recipient.member, 'profile') \
and validate_email(recipient.member.profile.email2):
email_to_send.recipient = recipient.member.profile.email2
email_to_send.send(connection=connection)
counter += 1
print(u"Newsletter sent to {}".format(
str(recipient.member.profile.email2)))
if newsletter.send_status == 'sending':
newsletter.send_status = 'sent'
newsletter.date_email_sent = datetime.datetime.now()
elif newsletter.send_status == 'resending':
newsletter.send_status = 'resent'
newsletter.date_last_resent = datetime.datetime.now()
if not newsletter.resend_count:
newsletter.resend_count = 0
newsletter.resend_count += 1
newsletter.email_sent_count = counter
newsletter.save()
print("Successfully sent %s newsletter emails." % counter)
print("Sending confirmation message to creator...")
# send confirmation email
subject = "Newsletter Submission Recap for %s" % newsletter.email.subject
detail_url = get_setting('site', 'global',
'siteurl') + newsletter.get_absolute_url()
params = {
'first_name': newsletter.email.creator.first_name,
'subject': newsletter.email.subject,
'count': counter,
'detail_url': detail_url
}
body = render_to_string(
template_name='newsletters/newsletter_sent_email_body.html',
context=params)
email = Email(recipient=newsletter.email.sender,
subject=subject,
body=body)
email.send(connection=connection)
print("Confirmation email sent.")
# add cache clear to resolve issue
# TODO: cache clear only to specifies
cache.clear()
print('Cache cleared!')
