def __init__(self):
self.site_display_name = get_setting('site', 'global', 'sitedisplayname')
self.site_contact_name = get_setting('site', 'global', 'sitecontactname')
self.site_contact_email = get_setting('site', 'global', 'sitecontactemail')
self.reply_to_email = get_setting('module', 'payments', 'paymentrecipients')
if not self.reply_to_email:
self.reply_to_email = self.site_contact_email
self.site_url = get_setting('site', 'global', 'siteurl')
self.email = Email()
self.email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
self.email.sender_display = self.site_display_name
self.email.reply_to = self.reply_to_email
self.admin_emails = self.get_admin_emails()
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 __init__(self):
self.site_display_name = get_setting('site', 'global', 'sitedisplayname')
self.site_contact_name = get_setting('site', 'global', 'sitecontactname')
self.site_contact_email = get_setting('site', 'global', 'sitecontactemail')
self.reply_to_email = get_setting('module', 'payments', 'paymentrecipients')
if not self.reply_to_email:
self.reply_to_email = self.site_contact_email
self.site_url = get_setting('site', 'global', 'siteurl')
self.email = Email()
self.email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
self.email.sender_display = self.site_display_name
self.email.reply_to = self.reply_to_email
self.admin_emails = self.get_admin_emails()
def __init__(self):
self.site_display_name = get_setting("site", "global", "sitedisplayname")
self.site_contact_name = get_setting("site", "global", "sitecontactname")
self.site_contact_email = get_setting("site", "global", "sitecontactemail")
self.reply_to_email = get_setting("module", "payments", "paymentrecipients")
if not self.reply_to_email:
self.reply_to_email = self.site_contact_email
self.site_url = get_setting("site", "global", "siteurl")
self.email = Email()
self.email.sender = get_setting("site", "global", "siteemailnoreplyaddress")
self.email.sender_display = self.site_display_name
self.email.reply_to = self.reply_to_email
self.admin_emails = self.get_admin_emails()
def send_organizer_confirmation(self, event):
from tendenci.core.emails.models import Email
from tendenci.core.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 send_organizer_confirmation(self, event):
from tendenci.core.emails.models import Email
from tendenci.core.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 save(self, *args, **kwargs):
data = self.cleaned_data
subject = ''
subj = data.get('subject', '')
inc_last_name = data.get('personalize_subject_last_name')
inc_first_name = data.get('personalize_subject_first_name')
if inc_first_name and not inc_last_name:
subject = '[firstname] ' + subj
elif inc_last_name and not inc_first_name:
subject = '[lastname] ' + subj
elif inc_first_name and inc_last_name:
subject = '[firstname] [lastname] ' + subj
else:
subject = subj
nl = super(OldGenerateForm, self).save(*args, **kwargs)
nl.subject = subject
nl.actionname = subject
nl.date_created = datetime.datetime.now()
nl.send_status = 'draft'
if nl.default_template:
template = render_to_string(nl.default_template, context_instance=RequestContext(self.request))
email_content = nl.generate_newsletter(self.request, template)
email = Email()
email.subject = subject
email.body = email_content
email.sender = self.request.user.email
email.sender_display = self.request.user.profile.get_name()
email.reply_to = self.request.user.email
email.creator = self.request.user
email.creator_username = self.request.user.username
email.owner = self.request.user
email.owner_username = self.request.user.username
email.save()
nl.email = email
nl.save()
return nl
def process_export(export_fields='all_fields', identifier=u'', user_id=0):
from tendenci.core.perms.models import TendenciBaseModel
if export_fields == 'main_fields':
user_field_list = ['username', 'first_name', 'last_name', 'email']
profile_field_list = [
'salutation', 'initials', 'display_name', 'company', 'department',
'position_title', 'sex', 'address', 'address2', 'city', 'state',
'zipcode', 'country', 'phone', 'phone2', 'fax', 'work_phone',
'home_phone', 'mobile_phone', 'url', 'url2', 'dob', 'status_detail'
]
else:
# base ------------
base_field_list = [
smart_str(field.name) for field in TendenciBaseModel._meta.fields
if not field.__class__ == AutoField
]
# user ------------
user_field_list = [
smart_str(field.name) for field in User._meta.fields
if not field.__class__ == AutoField
]
user_field_list.remove('password')
# profile ---------
profile_field_list = [
smart_str(field.name) for field in Profile._meta.fields
if not field.__class__ == AutoField
]
profile_field_list = [
name for name in profile_field_list if not name in base_field_list
]
profile_field_list.remove('guid')
profile_field_list.remove('user')
# append base fields at the end
field_list = user_field_list + profile_field_list
identifier = identifier or int(ttime.time())
file_name_temp = 'export/profiles/%s_temp.csv' % identifier
with default_storage.open(file_name_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_list)
profiles = Profile.objects.all()
for profile in profiles:
p_user = profile.user
items_list = []
for field_name in field_list:
if field_name in profile_field_list:
item = getattr(profile, field_name)
elif field_name in user_field_list:
item = getattr(p_user, field_name)
else:
item = ''
if item:
if isinstance(item, datetime):
item = item.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(item, date):
item = item.strftime('%Y-%m-%d')
elif isinstance(item, time):
item = item.strftime('%H:%M:%S')
elif isinstance(item, basestring):
item = item.encode("utf-8")
item = smart_str(item).decode('utf-8')
items_list.append(item)
csv_writer.writerow(items_list)
# rename the file name
file_name = 'export/profiles/%s.csv' % identifier
default_storage.save(file_name, default_storage.open(file_name_temp, 'rb'))
# delete the temp file
default_storage.delete(file_name_temp)
# notify user that export is ready to download
[user] = User.objects.filter(pk=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('profile.export_download', args=[identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name,
'export_fields': export_fields
}
subject = render_to_string(
'profiles/notices/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string('profiles/notices/export_ready_body.html',
parms)
email = Email(recipient=user.email, subject=subject, body=body)
email.send()
def handle(self, *args, **options):
verbosity = 1
if 'verbosity' in options:
verbosity = options['verbosity']
from django.conf import settings
from tendenci.addons.memberships.models import (Notice,
MembershipDefault,
NoticeLog,
NoticeDefaultLogRecord)
from tendenci.core.base.utils import fieldify
from tendenci.core.emails.models import Email
from tendenci.core.site_settings.utils import get_setting
site_display_name = get_setting('site', 'global', 'sitedisplayname')
site_contact_name = get_setting('site', 'global', 'sitecontactname')
site_contact_email = get_setting('site', 'global', 'sitecontactemail')
site_url = get_setting('site', 'global', 'siteurl')
corp_replace_str = """
<br /><br />
<font color="#FF0000">
Organizational Members, please contact your company
Membership coordinator
to ensure that your membership is being renewed.
</font>
"""
email = Email()
email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email.sender_display = site_display_name
email.reply_to = site_contact_email
now = datetime.now()
nowstr = time.strftime("%d-%b-%y %I:%M %p", now.timetuple())
def email_admins_recap(notices, total_sent):
"""Send admins recap after the notices were processed.
"""
email.recipient = get_admin_emails()
if email.recipient:
template_name = "memberships/notices/email_recap.html"
try:
recap_email_content = render_to_string(
template_name,
{'notices': notices,
'total_sent': total_sent,
'site_url': site_url,
'site_display_name': site_display_name,
'site_contact_name': site_contact_name,
'site_contact_email': site_contact_email})
email.body = recap_email_content
email.content_type = "html"
email.subject = '%s Membership Notices Distributed' % (
site_display_name)
email.send()
except TemplateDoesNotExist:
pass
def email_script_errors(err_msg):
"""Send error message to us if any.
"""
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 Processing Membership Notices on %s' % (
site_url)
email.send()
def get_script_support_emails():
admins = getattr(settings, 'ADMINS', None)
if admins:
recipients_list = [admin[1] for admin in admins]
return ','.join(recipients_list)
return None
def get_admin_emails():
admin_emails = get_setting('module', 'memberships',
'membershiprecipients').strip()
if admin_emails:
admin_emails = admin_emails.split(',')
if not admin_emails:
admin_emails = (get_setting('site', 'global',
'admincontactemail'
).strip()).split(',')
if admin_emails:
admin_emails = ','.join(admin_emails)
return admin_emails
def process_notice(notice):
notice.members_sent = []
num_sent = 0
if notice.notice_time == 'before':
start_dt = now + timedelta(days=notice.num_days)
else:
start_dt = now - timedelta(days=notice.num_days)
if notice.notice_type == 'disapprove':
status_detail_list = ['disapproved']
else:
status_detail_list = ['active', 'expired']
memberships = MembershipDefault.objects.filter(
status=True,
status_detail__in=status_detail_list
)
if notice.notice_type == 'join':
memberships = memberships.filter(
join_dt__year=start_dt.year,
join_dt__month=start_dt.month,
join_dt__day=start_dt.day,
renewal=False)
elif notice.notice_type == 'renewal':
memberships = memberships.filter(
renew_dt__year=start_dt.year,
renew_dt__month=start_dt.month,
renew_dt__day=start_dt.day,
renewal=True)
elif notice.notice_type == 'approve':
memberships = memberships.filter(
application_approved_denied_dt__year=start_dt.year,
application_approved_denied_dt__month=start_dt.month,
application_approved_denied_dt__day=start_dt.day,
application_approved=True)
elif notice.notice_type == 'disapprove':
memberships = memberships.filter(
application_approved_denied_dt__year=start_dt.year,
application_approved_denied_dt__month=start_dt.month,
application_approved_denied_dt__day=start_dt.day,
application_approved=False)
else: # 'expire'
memberships = memberships.filter(
expire_dt__year=start_dt.year,
expire_dt__month=start_dt.month,
expire_dt__day=start_dt.day)
# filter by membership type
if notice.membership_type:
memberships = memberships.filter(
membership_type=notice.membership_type)
memberships_count = memberships.count()
if memberships_count > 0:
email.content_type = notice.content_type
# password
passwd_str = """
If you've forgotten your password or need to reset
the auto-generated one, click <a href="%s%s">here</a>
and follow the instructions on the page to
reset your password.
""" % (site_url, reverse('auth_password_reset'))
global_context = {'sitedisplayname': site_display_name,
'sitecontactname': site_contact_name,
'sitecontactemail': site_contact_email,
'timesubmitted': nowstr,
'password': passwd_str
}
# log notice sent
notice_log = NoticeLog(notice=notice,
num_sent=0)
notice_log.save()
notice.log = notice_log
notice.err = ''
for membership in memberships:
try:
email_member(notice, membership, global_context)
if memberships_count <= 50:
notice.members_sent.append(membership)
num_sent += 1
# log record
notice_log_record = NoticeDefaultLogRecord(
notice_log=notice_log,
membership=membership)
notice_log_record.save()
except:
# catch the exception and email
notice.err += traceback.format_exc()
print traceback.format_exc()
if num_sent > 0:
notice_log.num_sent = num_sent
notice_log.save()
return num_sent
def email_member(notice, membership, global_context):
user = membership.user
body = notice.email_content
context = membership.get_field_items()
context['membership'] = membership
context.update(global_context)
# memberships page ------------
memberships_page = "%s%s" % \
(site_url, reverse('profile', args=[membership.user]))
body = body.replace("[membershiptypeid]",
str(membership.membership_type.id))
body = body.replace("[membershiplink]",
'%s' % memberships_page)
body = body.replace("[renewlink]", memberships_page)
if membership.expire_dt:
body = body.replace("[expirationdatetime]",
time.strftime(
"%d-%b-%y %I:%M %p",
membership.expire_dt.timetuple()))
else:
body = body.replace("[expirationdatetime]", '')
# corporate member corp_replace_str
if membership.corporate_membership_id:
body = body.replace("<!--[corporatemembernotice]-->",
corp_replace_str)
else:
body = body.replace("<!--[corporatemembernotice]-->", "")
context.update({'membershiptypeid':
str(membership.membership_type.id),
'membershiplink': memberships_page,
'renewlink': memberships_page,
'membernumber': membership.member_number,
'membershiptype': membership.membership_type.name,
})
if membership.expire_dt:
context['expirationdatetime'] = time.strftime(
"%d-%b-%y %I:%M %p",
membership.expire_dt.timetuple())
# corporate member corp_replace_str
if membership.corporate_membership_id:
context['corporatemembernotice'] = corp_replace_str
body = fieldify(body)
body = '%s <br /><br />%s' % (body, get_footer())
context = Context(context)
template = Template(body)
body = template.render(context)
email.recipient = user.email
subject = notice.subject.replace('(name)',
user.get_full_name())
template = Template(subject)
subject = template.render(context)
email.subject = subject
email.body = body
if notice.sender:
email.sender = notice.sender
email.reply_to = notice.sender
if notice.sender_display:
email.sender_display = notice.sender_display
email.send()
if verbosity > 1:
print 'To ', email.recipient, email.subject
def get_footer():
return """
This e-mail was generated by Tendenci® Software -
a web based membership management software solution
www.tendenci.com developed by Schipul - The Web
Marketing Company
"""
exception_str = ""
notices = Notice.objects.filter(status=True, status_detail='active'
).exclude(notice_time='attimeof')
if notices:
if verbosity > 1:
print "Start sending out notices to members:"
total_notices = 0
total_sent = 0
for notice in notices:
total_notices += 1
total_sent += process_notice(notice)
if hasattr(notice, 'err'):
exception_str += notice.err
if total_sent > 0:
processed_notices = [notice for notice in notices if hasattr(
notice, 'log'
) and notice.log.num_sent > 0]
email_admins_recap(processed_notices, total_sent)
# if there is any error, notify us
if exception_str:
email_script_errors(exception_str)
if verbosity > 1:
print 'Total notice processed: %d' % (total_notices)
print 'Total email sent: %d' % (total_sent)
print "Done"
else:
if verbosity > 1:
print "No notices on the site."
def process_export(
group_id,
export_target='all',
identifier=u'', user_id=0):
"""
Process export for group members and/or group subscribers.
"""
[group] = Group.objects.filter(id=group_id)[:1] or [None]
if not group:
return
# pull 100 rows per query
# be careful of the memory usage
rows_per_batch = 100
identifier = identifier or str(time.time())
file_dir = 'export/groups/'
file_path_temp = '%sgroup_%d_%s_%s_temp.csv' % (file_dir,
group.id,
export_target,
identifier)
# labels
user_fields = ['id',
'first_name',
'last_name',
'email',
'is_active',
'is_staff',
'is_superuser']
profile_fields = ['direct_mail',
'company',
'address',
'address2',
'city',
'state',
'zipcode',
'country',
'phone',
'create_dt']
labels = user_fields + profile_fields
field_dict = OrderedDict([(label.lower().replace(" ", "_"), ''
) for label in labels])
with default_storage.open(file_path_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_dict.keys())
# process regular group members
count_members = group.members.filter(
group_member__status=True,
group_member__status_detail='active').count()
num_rows_processed = 0
while num_rows_processed < count_members:
users = group.members.filter(
group_member__status=True,
group_member__status_detail='active'
).select_related('profile'
)[num_rows_processed:(num_rows_processed + rows_per_batch)]
num_rows_processed += rows_per_batch
row_dict = field_dict.copy()
for user in users:
profile = user.profile
for field_name in user_fields:
if hasattr(user, field_name):
row_dict[field_name] = getattr(user, field_name)
for field_name in profile_fields:
if hasattr(profile, field_name):
row_dict[field_name] = getattr(profile, field_name)
for k, v in row_dict.items():
if not isinstance(v, basestring):
if isinstance(v, datetime):
row_dict[k] = v.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(v, date):
row_dict[k] = v.strftime('%Y-%m-%d')
else:
row_dict[k] = smart_str(v)
csv_writer.writerow(row_dict.values())
# rename the file name
file_path = '%sgroup_%d_%s_%s.csv' % (file_dir,
group.id,
export_target,
identifier)
default_storage.save(file_path, default_storage.open(file_path_temp, 'rb'))
# delete the temp file
default_storage.delete(file_path_temp)
# notify user that export is ready to download
[user] = User.objects.filter(id=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('group.members_export_download',
args=[group.slug, export_target, identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'group': group,
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name}
subject = render_to_string(
'user_groups/exports/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string(
'user_groups/exports/export_ready_body.html', parms)
email = Email(
recipient=user.email,
subject=subject,
body=body)
email.send()
def handle(self, *args, **options):
from tendenci.addons.events.models import Event, Registrant, Organizer
from tendenci.core.emails.models import Email
from tendenci.core.site_settings.utils import get_setting
from tendenci.core.base.utils import convert_absolute_urls
from tendenci.addons.events.utils import (render_event_email,
get_default_reminder_template)
verbosity = options['verbosity']
site_url = get_setting('site', 'global', 'siteurl')
now = datetime.now()
today_tuple = (datetime(now.year, now.month, now.day, 0, 0, 0),
datetime(now.year, now.month, now.day, 23, 59, 59))
# get a list of upcoming events that are specified to send reminders.
events = Event.objects.filter(start_dt__gt=now,
registration_configuration__enabled=True,
registration_configuration__send_reminder=True,
status=True,
status_detail='active')
events_list = []
if events:
for event in events:
reg_conf = event.registration_configuration
reminder_days = reg_conf.reminder_days
if not reminder_days:
reminder_days = '1'
days_list = reminder_days.split(',')
for day in days_list:
try:
day = int(day)
except:
continue
start_dt = event.start_dt - timedelta(days=day)
if today_tuple[0] <= start_dt and start_dt <= today_tuple[1]:
events_list.append(event)
break
for event in events_list:
registrants = Registrant.objects.filter(
reminder=True,
registration__event=event
)
reg_conf = event.registration_configuration
[organizer] = Organizer.objects.filter(event=event)[:1] or [None]
event.organizer = organizer
email = reg_conf.email
if not email:
email = Email()
if not email.sender_display:
if organizer.name:
email.sender_display = organizer.name
if not email.reply_to:
if organizer.user and organizer.user.email:
email.reply_to = organizer.user.email
if not email.subject:
email.subject = 'Reminder: %s' % event.title
else:
email.subject = 'Reminder: %s' % email.subject
if not email.body:
email.body = get_default_reminder_template(event)
email = render_event_email(event, email)
# replace the relative links with absolute urls
# in the email body and subject
email.body = convert_absolute_urls(email.body, site_url)
event.email = email
self.send_reminders(event, registrants, verbosity=verbosity)
class RecurringPaymentEmailNotices(object):
def __init__(self):
self.site_display_name = get_setting("site", "global", "sitedisplayname")
self.site_contact_name = get_setting("site", "global", "sitecontactname")
self.site_contact_email = get_setting("site", "global", "sitecontactemail")
self.reply_to_email = get_setting("module", "payments", "paymentrecipients")
if not self.reply_to_email:
self.reply_to_email = self.site_contact_email
self.site_url = get_setting("site", "global", "siteurl")
self.email = Email()
self.email.sender = get_setting("site", "global", "siteemailnoreplyaddress")
self.email.sender_display = self.site_display_name
self.email.reply_to = self.reply_to_email
self.admin_emails = self.get_admin_emails()
def get_admin_emails(self):
payment_admins = get_setting("module", "payments", "paymentrecipients")
if payment_admins:
payment_admins = payment_admins.split(",")
admin_emails = payment_admins
else:
admin_emails = (get_setting("site", "global", "admincontactemail")).split(",")
if admin_emails:
admin_emails = ",".join(admin_emails)
return admin_emails
def get_script_support_emails(self):
admins = getattr(settings, "ADMINS", None)
if admins:
recipients_list = [admin[1] for admin in admins]
return ",".join(recipients_list)
return None
def email_script_support_transaction_error(self, payment_transaction):
"""if there is an error other than transaction not being approved, notify us.
"""
self.email.recipient = self.get_script_support_emails()
if self.email.recipient:
template_name = "recurring_payments/email_script_support_transaction.html"
try:
email_content = render_to_string(
template_name,
{"pt": payment_transaction, "site_display_name": self.site_display_name, "site_url": self.site_url},
)
self.email.body = email_content
self.email.content_type = "html"
self.email.priority = 1
self.email.subject = "Recurring payment transaction error on %s" % (self.site_display_name)
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_transaction_result(self, payment_transaction, success=True):
"""Send admins the result after the transaction is processed.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_transaction.html"
user_in_texas = False
if payment_transaction.payment.state:
if payment_transaction.payment.state.lower() in ["texas", "tx"]:
user_in_texas = True
try:
email_content = render_to_string(
template_name,
{
"pt": payment_transaction,
"site_display_name": self.site_display_name,
"site_url": self.site_url,
"user_in_texas": user_in_texas,
},
)
self.email.body = email_content
self.email.content_type = "html"
if not success:
self.email.subject = "Recurring payment transaction failed on %s" % (self.site_display_name)
self.email.priority = 1
else:
self.email.subject = "Recurring payment transaction processed on %s" % (self.site_display_name)
self.email.send()
except TemplateDoesNotExist:
pass
def email_customer_transaction_result(self, payment_transaction):
"""Send customer an email after the transaction is processed.
"""
self.email.recipient = payment_transaction.recurring_payment.user.email
if self.email.recipient:
template_name = "recurring_payments/email_customer_transaction.html"
try:
email_content = render_to_string(
template_name,
{"pt": payment_transaction, "site_display_name": self.site_display_name, "site_url": self.site_url},
)
self.email.body = email_content
self.email.content_type = "html"
if payment_transaction.status:
self.email.subject = "Payment received "
else:
self.email.subject = "Payment failed "
self.email.subject = "%s for %s " % (
self.email.subject,
payment_transaction.recurring_payment.description,
)
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_no_payment_profile(self, recurring_payment):
"""Notify admin that payment method hasn't been setup yet for this recurring payment entry.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_no_payment_profile.html"
try:
email_content = render_to_string(
template_name,
{"rp": recurring_payment, "site_display_name": self.site_display_name, "site_url": self.site_url},
)
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = "Payment method not setup for %s on %s" % (
recurring_payment,
self.site_display_name,
)
self.email.send()
except TemplateDoesNotExist:
pass
def email_customer_no_payment_profile(self, recurring_payment):
"""Notify customer that payment method hasn't been setup yet for this recurring payment entry.
"""
self.email.recipient = recurring_payment.user.email
if self.email.recipient:
template_name = "recurring_payments/email_customer_no_payment_profile.html"
try:
email_content = render_to_string(
template_name,
{"rp": recurring_payment, "site_display_name": self.site_display_name, "site_url": self.site_url},
)
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = "Please update your payment method for %s on %s" % (
recurring_payment.description,
self.site_display_name,
)
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_account_disabled(self, recurring_payment, user_by):
"""Notify admin that the recurring payment account is disabled.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_account_disabled.html"
try:
email_content = render_to_string(
template_name,
{
"rp": recurring_payment,
"user_by": user_by,
"site_display_name": self.site_display_name,
"site_url": self.site_url,
},
)
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = "Recurring Payment Account (ID:%d) Disabled by %s on %s" % (
recurring_payment.id,
user_by,
self.site_display_name,
)
self.email.send()
except TemplateDoesNotExist:
pass
def process_invoice_export(start_dt=None, end_dt=None,
identifier=u'', user_id=0):
fields = ['id',
'guid',
'object_type',
'object_id',
'title',
'tender_date',
'bill_to',
'bill_to_first_name',
'bill_to_last_name',
'bill_to_company',
'bill_to_address',
'bill_to_city',
'bill_to_state',
'bill_to_zip_code',
'bill_to_country',
'bill_to_phone',
'bill_to_fax',
'bill_to_email',
'ship_to',
'ship_to_first_name',
'ship_to_last_name',
'ship_to_company',
'ship_to_address',
'ship_to_city',
'ship_to_state',
'ship_to_zip_code',
'ship_to_country',
'ship_to_phone',
'ship_to_fax',
'ship_to_email',
'ship_to_address_type',
'receipt',
'gift',
'arrival_date_time',
'greeting',
'instructions',
'po',
'terms',
'due_date',
'ship_date',
'ship_via',
'fob',
'project',
'other',
'message',
'subtotal',
'shipping',
'shipping_surcharge',
'box_and_packing',
'tax_exempt',
'tax_exemptid',
'tax_rate',
'taxable',
'tax',
'variance',
'discount_amount',
'total',
'payments_credits',
'balance',
'disclaimer',
'variance_notes',
'admin_notes',
'create_dt',
'update_dt',
'creator',
'creator_username',
'owner',
'owner_username',
'status_detail']
identifier = identifier or int(ttime.time())
file_name_temp = 'export/invoices/%s_temp.csv' % identifier
with default_storage.open(file_name_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(fields)
invoices = Invoice.objects.filter(status=True,
update_dt__gte=start_dt,
update_dt__lte=end_dt)
for invoice in invoices:
items_list = []
for field_name in fields:
item = getattr(invoice, field_name)
if item is None:
item = ''
if item:
if isinstance(item, datetime):
item = item.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(item, date):
item = item.strftime('%Y-%m-%d')
elif isinstance(item, time):
item = item.strftime('%H:%M:%S')
elif isinstance(item, basestring):
item = item.encode("utf-8")
item = smart_str(item).decode('utf-8')
items_list.append(item)
csv_writer.writerow(items_list)
# rename the file name
file_name = 'export/invoices/%s.csv' % identifier
default_storage.save(file_name, default_storage.open(file_name_temp, 'rb'))
# delete the temp file
default_storage.delete(file_name_temp)
# notify user that export is ready to download
[user] = User.objects.filter(pk=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('invoice.export_download', args=[identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name,
'start_dt': start_dt,
'end_dt': end_dt}
subject = render_to_string(
'invoices/notices/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string(
'invoices/notices/export_ready_body.html', parms)
email = Email(
recipient=user.email,
subject=subject,
body=body)
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)
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():
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()
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()
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()
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)
# log an event for invoice add
EventLog.objects.log(instance=form)
# redirect to billing form
return redirect('form_entry_payment', invoice.id,
invoice.guid)
# default redirect
if form.completion_url:
return HttpResponseRedirect(form.completion_url)
return redirect("form_sent", form.slug)
# set form's template to default if no template or template doesn't exist
if not form.template or not template_exists(form.template):
form.template = "default.html"
context = {
"form": form,
"form_for_form": form_for_form,
'form_template': form.template,
}
return render_to_response(template, context, RequestContext(request))
def process_export(
group_id,
export_target='all',
identifier=u'', user_id=0):
"""
Process export for group members and/or group subscribers.
"""
[group] = Group.objects.filter(id=group_id)[:1] or [None]
if not group:
return
# pull 100 rows per query
# be careful of the memory usage
rows_per_batch = 100
identifier = identifier or str(time.time())
file_dir = 'export/groups/'
file_path_temp = '%sgroup_%d_%s_%s_temp.csv' % (file_dir,
group.id,
export_target,
identifier)
# labels
subscribers_labels = None
regular_labels = None
if export_target in ['subscribers', 'all']:
# get a list of labels for subscribers
subscribers_labels = list(set([label for (label, ) in
SubscriberData.objects.filter(
subscription__group=group
).values_list('field_label')
]))
if export_target in ['members', 'all']:
user_fields = [
'id',
'first_name',
'last_name',
'email',
'is_active',
'is_staff',
'is_superuser'
]
profile_fields = [
'direct_mail',
'company',
'address',
'address2',
'city',
'state',
'zipcode',
'country',
'phone',
'create_dt'
]
regular_labels = user_fields + profile_fields
if regular_labels and subscribers_labels:
labels = regular_labels + subscribers_labels
elif regular_labels:
labels = regular_labels
elif subscribers_labels:
labels = subscribers_labels
field_dict = OrderedDict([(label.lower().replace(" ", "_"), ''
) for label in labels])
with default_storage.open(file_path_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_dict.keys())
# process regular group members
if export_target in ['members', 'all']:
count_members = group.members.filter(
group_member__status=True,
group_member__status_detail='active'
).count()
num_rows_processed = 0
while num_rows_processed < count_members:
users = group.members.filter(
group_member__status=True,
group_member__status_detail='active'
).select_related('profile'
)[num_rows_processed:(num_rows_processed + rows_per_batch)]
num_rows_processed += rows_per_batch
row_dict = field_dict.copy()
for user in users:
profile = user.profile
for field_name in user_fields:
if hasattr(user, field_name):
row_dict[field_name] = getattr(user, field_name)
for field_name in profile_fields:
if hasattr(profile, field_name):
row_dict[field_name] = getattr(profile, field_name)
for k, v in row_dict.items():
if not isinstance(v, basestring):
if isinstance(v, datetime):
row_dict[k] = v.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(v, date):
row_dict[k] = v.strftime('%Y-%m-%d')
else:
row_dict[k] = smart_str(v)
csv_writer.writerow(row_dict.values())
# process for subscribers
if export_target in ['subscribers', 'all']:
count_subscriptions = GroupSubscription.objects.filter(
group=group
).count()
num_rows_processed = 0
while num_rows_processed < count_subscriptions:
subscription_ids = GroupSubscription.objects.filter(
group=group
).order_by('id'
).values_list('id', flat=True
)[num_rows_processed:(num_rows_processed + rows_per_batch)]
num_rows_processed += rows_per_batch
if subscription_ids:
ssdata = SubscriberData.objects.filter(
subscription__group=group,
subscription_id__in=subscription_ids
).order_by('subscription__id')
if ssdata:
prev_subscription_id = 0
row_dict = field_dict.copy()
# this batch of ssdata can contain up to 100 subscriptions
# we process one subscription at a time by remembering
# its previous subscription
for sd in ssdata:
if prev_subscription_id != 0 and \
sd.subscription.id != prev_subscription_id:
# write out the row
csv_writer.writerow(row_dict.values())
# reset row_dict
row_dict = field_dict.copy()
prev_subscription_id = sd.subscription.id
field_name = sd.field_label.lower().replace(" ", "_")
row_dict[field_name] = sd.value
# write out the last row
csv_writer.writerow(row_dict.values())
# rename the file name
file_path = '%sgroup_%d_%s_%s.csv' % (file_dir,
group.id,
export_target,
identifier)
default_storage.save(file_path, default_storage.open(file_path_temp, 'rb'))
# delete the temp file
default_storage.delete(file_path_temp)
# notify user that export is ready to download
[user] = User.objects.filter(id=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('group.members_export_download',
args=[group.slug, export_target, identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'group': group,
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name,
'export_target': export_target}
subject = render_to_string(
'user_groups/exports/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string(
'user_groups/exports/export_ready_body.html', parms)
email = Email(
recipient=user.email,
subject=subject,
body=body)
email.send()
def handle(self, *args, **options):
import datetime
from tendenci.core.emails.models import Email
from tendenci.core.newsletters.models import Newsletter
from tendenci.core.site_settings.utils import get_setting
from tendenci.core.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 = int(args[0])
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 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 = self.site_url + \
reverse('newsletter.detail.view', kwargs={'pk': newsletter.pk})
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 process_export(export_fields='all_fields', export_status_detail='',
identifier=u'', user_id=0):
from tendenci.core.perms.models import TendenciBaseModel
if export_fields == 'main_fields':
field_list = [
'headline',
'slug',
'summary',
'body',
'source',
'first_name',
'last_name',
'address',
'address2',
'city',
'state',
'zip_code',
'country',
'phone',
'phone2',
'fax',
'email',
'email2',
'website',
'list_type',
'requested_duration',
'activation_dt',
'expiration_dt',
'tags',
'enclosure_url',
'enclosure_type',
'enclosure_length',
'status',
'status_detail']
else:
# base ------------
base_field_list = [
smart_str(field.name) for field in TendenciBaseModel._meta.fields
if not field.__class__ == AutoField]
field_list = [
smart_str(field.name) for field in Directory._meta.fields
if not field.__class__ == AutoField]
field_list = [
name for name in field_list
if not name in base_field_list]
field_list.remove('guid')
# append base fields at the end
field_list = field_list + base_field_list
identifier = identifier or int(ttime.time())
file_name_temp = 'export/directories/%s_temp.csv' % identifier
with default_storage.open(file_name_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_list)
directories = Directory.objects.all()
if export_status_detail:
directories = directories.filter(status_detail__icontains=export_status_detail)
for directory in directories:
items_list = []
for field_name in field_list:
item = getattr(directory, field_name)
if item is None:
item = ''
if item:
if isinstance(item, datetime):
item = item.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(item, date):
item = item.strftime('%Y-%m-%d')
elif isinstance(item, time):
item = item.strftime('%H:%M:%S')
elif isinstance(item, basestring):
item = item.encode("utf-8")
elif field_name == 'invoice':
# display total vs balance
item = 'Total: %d / Balance: %d' % (item.total, item.balance)
item = smart_str(item).decode('utf-8')
items_list.append(item)
csv_writer.writerow(items_list)
# rename the file name
file_name = 'export/directories/%s.csv' % identifier
default_storage.save(file_name, default_storage.open(file_name_temp, 'rb'))
# delete the temp file
default_storage.delete(file_name_temp)
# notify user that export is ready to download
[user] = User.objects.filter(pk=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('directory.export_download', args=[identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name,
'export_status_detail': export_status_detail,
'export_fields': export_fields}
subject = render_to_string(
'directories/notices/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string(
'directories/notices/export_ready_body.html', parms)
email = Email(
recipient=user.email,
subject=subject,
body=body)
email.send()
def handle(self, *args, **options):
from tendenci.addons.events.models import Event, Registrant, Organizer
from tendenci.core.emails.models import Email
from tendenci.core.site_settings.utils import get_setting
from tendenci.core.base.utils import convert_absolute_urls
from tendenci.addons.events.utils import (render_event_email,
get_default_reminder_template)
verbosity = options['verbosity']
site_url = get_setting('site', 'global', 'siteurl')
now = datetime.now()
today_tuple = (datetime(now.year, now.month, now.day, 0, 0, 0),
datetime(now.year, now.month, now.day, 23, 59, 59))
# get a list of upcoming events that are specified to send reminders.
events = Event.objects.filter(start_dt__gt=now,
registration_configuration__enabled=True,
registration_configuration__send_reminder=True,
status=True,
status_detail='active')
events_list = []
if events:
for event in events:
reg_conf = event.registration_configuration
reminder_days = reg_conf.reminder_days
if not reminder_days:
reminder_days = '1'
days_list = reminder_days.split(',')
for day in days_list:
try:
day = int(day)
except:
continue
start_dt = event.start_dt - timedelta(days=day)
if today_tuple[0] <= start_dt and start_dt <= today_tuple[1]:
events_list.append(event)
break
for event in events_list:
registrants = Registrant.objects.filter(
reminder=True,
registration__event=event,
cancel_dt=None
)
reg_conf = event.registration_configuration
[organizer] = Organizer.objects.filter(event=event)[:1] or [None]
event.organizer = organizer
email = reg_conf.email
if not email:
email = Email()
if not email.sender_display:
if organizer.name:
email.sender_display = organizer.name
if not email.reply_to:
if organizer.user and organizer.user.email:
email.reply_to = organizer.user.email
if not email.subject:
email.subject = 'Reminder: %s' % event.title
else:
email.subject = 'Reminder: %s' % email.subject
if not email.body:
email.body = get_default_reminder_template(event)
email = render_event_email(event, email)
# replace the relative links with absolute urls
# in the email body and subject
email.body = convert_absolute_urls(email.body, site_url)
event.email = email
self.send_reminders(event, registrants, verbosity=verbosity)
def save(self, *args, **kwargs):
data = self.cleaned_data
subject = ''
subj = data.get('subject', '')
inc_last_name = data.get('personalize_subject_last_name')
inc_first_name = data.get('personalize_subject_first_name')
if inc_first_name and not inc_last_name:
subject = '[firstname] ' + subj
elif inc_last_name and not inc_first_name:
subject = '[lastname] ' + subj
elif inc_first_name and inc_last_name:
subject = '[firstname] [lastname] ' + subj
else:
subject = subj
nl = super(OldGenerateForm, self).save(*args, **kwargs)
nl.subject = subject
nl.actionname = subject
nl.date_created = datetime.datetime.now()
nl.send_status = 'draft'
if nl.default_template:
template = render_to_string(nl.default_template,
context_instance=RequestContext(
self.request))
email_content = nl.generate_newsletter(self.request, template)
email = Email()
email.subject = subject
email.body = email_content
email.sender = self.request.user.email
email.sender_display = self.request.user.profile.get_name()
email.reply_to = self.request.user.email
email.creator = self.request.user
email.creator_username = self.request.user.username
email.owner = self.request.user
email.owner_username = self.request.user.username
email.save()
nl.email = email
nl.save()
return nl
def process_export(export_fields="all_fields", identifier=u"", user_id=0):
from tendenci.core.perms.models import TendenciBaseModel
if export_fields == "main_fields":
user_field_list = ["username", "first_name", "last_name", "email"]
profile_field_list = [
"salutation",
"initials",
"display_name",
"company",
"department",
"position_title",
"sex",
"address",
"address2",
"city",
"state",
"zipcode",
"country",
"phone",
"phone2",
"fax",
"work_phone",
"home_phone",
"mobile_phone",
"url",
"url2",
"dob",
"status_detail",
]
else:
# base ------------
base_field_list = [
smart_str(field.name) for field in TendenciBaseModel._meta.fields if not field.__class__ == AutoField
]
# user ------------
user_field_list = [smart_str(field.name) for field in User._meta.fields if not field.__class__ == AutoField]
user_field_list.remove("password")
# profile ---------
profile_field_list = [
smart_str(field.name) for field in Profile._meta.fields if not field.__class__ == AutoField
]
profile_field_list = [name for name in profile_field_list if not name in base_field_list]
profile_field_list.remove("guid")
profile_field_list.remove("user")
# append base fields at the end
field_list = user_field_list + profile_field_list
identifier = identifier or int(ttime.time())
file_name_temp = "export/profiles/%s_temp.csv" % identifier
with default_storage.open(file_name_temp, "wb") as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding="utf-8")
csv_writer.writerow(field_list)
profiles = Profile.objects.all()
for profile in profiles:
p_user = profile.user
items_list = []
for field_name in field_list:
if field_name in profile_field_list:
item = getattr(profile, field_name)
elif field_name in user_field_list:
item = getattr(p_user, field_name)
else:
item = ""
if item:
if isinstance(item, datetime):
item = item.strftime("%Y-%m-%d %H:%M:%S")
elif isinstance(item, date):
item = item.strftime("%Y-%m-%d")
elif isinstance(item, time):
item = item.strftime("%H:%M:%S")
elif isinstance(item, basestring):
item = item.encode("utf-8")
item = smart_str(item).decode("utf-8")
items_list.append(item)
csv_writer.writerow(items_list)
# rename the file name
file_name = "export/profiles/%s.csv" % identifier
default_storage.save(file_name, default_storage.open(file_name_temp, "rb"))
# delete the temp file
default_storage.delete(file_name_temp)
# notify user that export is ready to download
[user] = User.objects.filter(pk=user_id)[:1] or [None]
if user and user.email:
download_url = reverse("profile.export_download", args=[identifier])
site_url = get_setting("site", "global", "siteurl")
site_display_name = get_setting("site", "global", "sitedisplayname")
parms = {
"download_url": download_url,
"user": user,
"site_url": site_url,
"site_display_name": site_display_name,
"export_fields": export_fields,
}
subject = render_to_string("profiles/notices/export_ready_subject.html", parms)
subject = subject.strip("\n").strip("\r")
body = render_to_string("profiles/notices/export_ready_body.html", parms)
email = Email(recipient=user.email, subject=subject, body=body)
email.send()
def process_export(export_fields='all_fields',
export_status_detail='',
identifier=u'',
user_id=0):
from tendenci.core.perms.models import TendenciBaseModel
if export_fields == 'main_fields':
field_list = [
'headline', 'slug', 'summary', 'body', 'source', 'first_name',
'last_name', 'address', 'address2', 'city', 'state', 'zip_code',
'country', 'phone', 'phone2', 'fax', 'email', 'email2', 'website',
'list_type', 'requested_duration', 'activation_dt',
'expiration_dt', 'tags', 'enclosure_url', 'enclosure_type',
'enclosure_length', 'status', 'status_detail'
]
else:
# base ------------
base_field_list = [
smart_str(field.name) for field in TendenciBaseModel._meta.fields
if not field.__class__ == AutoField
]
field_list = [
smart_str(field.name) for field in Directory._meta.fields
if not field.__class__ == AutoField
]
field_list = [
name for name in field_list if not name in base_field_list
]
field_list.remove('guid')
# append base fields at the end
field_list = field_list + base_field_list
identifier = identifier or int(ttime.time())
file_name_temp = 'export/directories/%s_temp.csv' % identifier
with default_storage.open(file_name_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_list)
directories = Directory.objects.all()
if export_status_detail:
directories = directories.filter(
status_detail__icontains=export_status_detail)
for directory in directories:
items_list = []
for field_name in field_list:
item = getattr(directory, field_name)
if item is None:
item = ''
if item:
if isinstance(item, datetime):
item = item.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(item, date):
item = item.strftime('%Y-%m-%d')
elif isinstance(item, time):
item = item.strftime('%H:%M:%S')
elif isinstance(item, basestring):
item = item.encode("utf-8")
elif field_name == 'invoice':
# display total vs balance
item = 'Total: %d / Balance: %d' % (item.total,
item.balance)
item = smart_str(item).decode('utf-8')
items_list.append(item)
csv_writer.writerow(items_list)
# rename the file name
file_name = 'export/directories/%s.csv' % identifier
default_storage.save(file_name, default_storage.open(file_name_temp, 'rb'))
# delete the temp file
default_storage.delete(file_name_temp)
# notify user that export is ready to download
[user] = User.objects.filter(pk=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('directory.export_download', args=[identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name,
'export_status_detail': export_status_detail,
'export_fields': export_fields
}
subject = render_to_string(
'directories/notices/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string('directories/notices/export_ready_body.html',
parms)
email = Email(recipient=user.email, subject=subject, body=body)
email.send()
class RecurringPaymentEmailNotices(object):
def __init__(self):
self.site_display_name = get_setting('site', 'global', 'sitedisplayname')
self.site_contact_name = get_setting('site', 'global', 'sitecontactname')
self.site_contact_email = get_setting('site', 'global', 'sitecontactemail')
self.reply_to_email = get_setting('module', 'payments', 'paymentrecipients')
if not self.reply_to_email:
self.reply_to_email = self.site_contact_email
self.site_url = get_setting('site', 'global', 'siteurl')
self.email = Email()
self.email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
self.email.sender_display = self.site_display_name
self.email.reply_to = self.reply_to_email
self.admin_emails = self.get_admin_emails()
def get_admin_emails(self):
payment_admins = get_setting('module', 'payments', 'paymentrecipients')
if payment_admins:
payment_admins = payment_admins.split(',')
admin_emails = payment_admins
else:
admin_emails = (get_setting('site', 'global', 'admincontactemail')).split(',')
if admin_emails:
admin_emails = ','.join(admin_emails)
return admin_emails
def get_script_support_emails(self):
admins = getattr(settings, 'ADMINS', None)
if admins:
recipients_list = [admin[1] for admin in admins]
return ','.join(recipients_list)
return None
def email_script_support_transaction_error(self, payment_transaction):
"""if there is an error other than transaction not being approved, notify us.
"""
self.email.recipient = self.get_script_support_emails()
if self.email.recipient:
template_name = "recurring_payments/email_script_support_transaction.html"
try:
email_content = render_to_string(template_name,
{'pt':payment_transaction,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
self.email.priority = 1
self.email.subject = 'Recurring payment transaction error on %s' % (
self.site_display_name)
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_transaction_result(self, payment_transaction, success=True):
"""Send admins the result after the transaction is processed.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_transaction.html"
user_in_texas = False
if payment_transaction.payment.state:
if payment_transaction.payment.state.lower() in ['texas', 'tx']:
user_in_texas = True
try:
email_content = render_to_string(template_name,
{'pt':payment_transaction,
'site_display_name': self.site_display_name,
'site_url': self.site_url,
'user_in_texas': user_in_texas
})
self.email.body = email_content
self.email.content_type = "html"
if not success:
self.email.subject = 'Recurring payment transaction failed on %s' % (
self.site_display_name)
self.email.priority = 1
else:
self.email.subject = 'Recurring payment transaction processed on %s' % (
self.site_display_name)
self.email.send()
except TemplateDoesNotExist:
pass
def email_customer_transaction_result(self, payment_transaction):
"""Send customer an email after the transaction is processed.
"""
self.email.recipient = payment_transaction.recurring_payment.user.email
if self.email.recipient:
template_name = "recurring_payments/email_customer_transaction.html"
try:
email_content = render_to_string(template_name,
{'pt':payment_transaction,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
if payment_transaction.status:
self.email.subject = 'Payment received '
else:
self.email.subject = 'Payment failed '
self.email.subject = "%s for %s " % (self.email.subject,
payment_transaction.recurring_payment.description)
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_no_payment_profile(self, recurring_payment):
"""Notify admin that payment method hasn't been setup yet for this recurring payment entry.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_no_payment_profile.html"
try:
email_content = render_to_string(template_name,
{'rp':recurring_payment,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = 'Payment method not setup for %s on %s' % (
recurring_payment , self.site_display_name)
self.email.send()
except TemplateDoesNotExist:
pass
def email_customer_no_payment_profile(self, recurring_payment):
"""Notify customer that payment method hasn't been setup yet for this recurring payment entry.
"""
self.email.recipient = recurring_payment.user.email
if self.email.recipient:
template_name = "recurring_payments/email_customer_no_payment_profile.html"
try:
email_content = render_to_string(template_name,
{'rp':recurring_payment,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = 'Please update your payment method for %s on %s' % (
recurring_payment.description, self.site_display_name)
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_account_disabled(self, recurring_payment, user_by):
"""Notify admin that the recurring payment account is disabled.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_account_disabled.html"
try:
email_content = render_to_string(template_name,
{'rp':recurring_payment,
'user_by': user_by,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = 'Recurring Payment Account (ID:%d) Disabled by %s on %s' % (
recurring_payment.id, user_by, self.site_display_name)
self.email.send()
except TemplateDoesNotExist:
pass
def process_export(group_id, export_target='all', identifier=u'', user_id=0):
"""
Process export for group members and/or group subscribers.
"""
[group] = Group.objects.filter(id=group_id)[:1] or [None]
if not group:
return
# pull 100 rows per query
# be careful of the memory usage
rows_per_batch = 100
identifier = identifier or str(time.time())
file_dir = 'export/groups/'
file_path_temp = '%sgroup_%d_%s_%s_temp.csv' % (file_dir, group.id,
export_target, identifier)
# labels
user_fields = [
'id', 'first_name', 'last_name', 'email', 'is_active', 'is_staff',
'is_superuser'
]
profile_fields = [
'direct_mail', 'company', 'address', 'address2', 'city', 'state',
'zipcode', 'country', 'phone', 'create_dt'
]
labels = user_fields + profile_fields
field_dict = OrderedDict([(label.lower().replace(" ", "_"), '')
for label in labels])
with default_storage.open(file_path_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_dict.keys())
# process regular group members
count_members = group.members.filter(
group_member__status=True,
group_member__status_detail='active').count()
num_rows_processed = 0
while num_rows_processed < count_members:
users = group.members.filter(
group_member__status=True,
group_member__status_detail='active').select_related(
'profile')[num_rows_processed:(num_rows_processed +
rows_per_batch)]
num_rows_processed += rows_per_batch
row_dict = field_dict.copy()
for user in users:
profile = user.profile
for field_name in user_fields:
if hasattr(user, field_name):
row_dict[field_name] = getattr(user, field_name)
for field_name in profile_fields:
if hasattr(profile, field_name):
row_dict[field_name] = getattr(profile, field_name)
for k, v in row_dict.items():
if not isinstance(v, basestring):
if isinstance(v, datetime):
row_dict[k] = v.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(v, date):
row_dict[k] = v.strftime('%Y-%m-%d')
else:
row_dict[k] = smart_str(v)
csv_writer.writerow(row_dict.values())
# rename the file name
file_path = '%sgroup_%d_%s_%s.csv' % (file_dir, group.id, export_target,
identifier)
default_storage.save(file_path, default_storage.open(file_path_temp, 'rb'))
# delete the temp file
default_storage.delete(file_path_temp)
# notify user that export is ready to download
[user] = User.objects.filter(id=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('group.members_export_download',
args=[group.slug, export_target, identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'group': group,
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name
}
subject = render_to_string(
'user_groups/exports/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string('user_groups/exports/export_ready_body.html',
parms)
email = Email(recipient=user.email, subject=subject, body=body)
email.send()
def process_export(identifier, user_id):
field_list = [
'guid',
'slug',
'timezone',
'headline',
'summary',
'body',
'source',
'first_name',
'last_name',
'phone',
'fax',
'email',
'website',
'release_dt',
'syndicate',
'featured',
'design_notes',
'tags',
'enclosure_url',
'enclosure_type',
'enclosure_length',
'not_official_content',
'entity',
]
identifier = identifier or int(ttime.time())
file_name_temp = 'export/articles/%s_temp.csv' % (identifier)
with default_storage.open(file_name_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_list)
articles = Article.objects.filter(status_detail='active')
for article in articles:
items_list = []
for field_name in field_list:
item = getattr(article, field_name)
if isinstance(item, datetime):
item = item.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(item, date):
item = item.strftime('%Y-%m-%d')
elif isinstance(item, time):
item = item.strftime('%H:%M:%S')
elif isinstance(item, basestring):
item = item.encode("utf-8")
item = smart_str(item).decode('utf-8')
items_list.append(item)
csv_writer.writerow(items_list)
# rename the file name
file_name = 'export/articles/%s.csv' % identifier
default_storage.save(file_name, default_storage.open(file_name_temp, 'rb'))
# delete the temp file
default_storage.delete(file_name_temp)
# notify user that export is ready to download
[user] = User.objects.filter(pk=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('article.export_download', args=[identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name}
subject = render_to_string(
'articles/notices/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string(
'articles/notices/export_ready_body.html', parms)
email = Email(
recipient=user.email,
subject=subject,
body=body)
email.send()
def handle(self, *args, **options):
verbosity = 1
if "verbosity" in options:
verbosity = options["verbosity"]
# first test if we have notices set up
from tendenci.addons.corporate_memberships.models import Notice
if not Notice.objects.filter(status=True, status_detail="active").exclude(notice_time="attimeof").exists():
if verbosity > 1:
print ("No notices set up...existing...")
# no active notices to process. stop here
return
from tendenci.addons.corporate_memberships.models import CorpMembership, NoticeLog, NoticeLogRecord
from tendenci.core.base.utils import fieldify
from tendenci.core.emails.models import Email
from tendenci.core.site_settings.utils import get_setting
site_display_name = get_setting("site", "global", "sitedisplayname")
site_contact_name = get_setting("site", "global", "sitecontactname")
site_contact_email = get_setting("site", "global", "sitecontactemail")
site_url = get_setting("site", "global", "siteurl")
email = Email()
email.sender = get_setting("site", "global", "siteemailnoreplyaddress")
email.sender_display = site_display_name
email.reply_to = site_contact_email
now = datetime.now()
nowstr = time.strftime("%d-%b-%y %I:%M %p", now.timetuple())
def email_admins_recap(notices, total_sent):
"""Send admins recap after the notices were processed.
"""
email.recipient = get_admin_emails()
if email.recipient:
template_name = "corporate_memberships/notices/email_recap.html"
try:
recap_email_content = render_to_string(
template_name,
{
"notices": notices,
"total_sent": total_sent,
"site_url": site_url,
"site_display_name": site_display_name,
"site_contact_name": site_contact_name,
"site_contact_email": site_contact_email,
},
)
email.body = recap_email_content
email.content_type = "html"
email.subject = "%s Corporate Membership Notices Distributed" % (site_display_name)
email.send()
except TemplateDoesNotExist:
pass
def email_script_errors(err_msg):
"""Send error message to us if any.
"""
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 Processing Corporate Membership Notices on %s" % (site_url)
email.send()
def get_script_support_emails():
admins = getattr(settings, "ADMINS", None)
if admins:
recipients_list = [admin[1] for admin in admins]
return ",".join(recipients_list)
return None
def get_admin_emails():
admin_emails = get_setting("module", "corporate_memberships", "corporatemembershiprecipients").strip()
if admin_emails:
admin_emails = admin_emails.split(",")
if not admin_emails:
admin_emails = (get_setting("site", "global", "admincontactemail").strip()).split(",")
if admin_emails:
admin_emails = ",".join(admin_emails)
return admin_emails
def process_notice(notice):
notice.members_sent = []
num_sent = 0
if notice.notice_time == "before":
start_dt = now + timedelta(days=notice.num_days)
else:
start_dt = now - timedelta(days=notice.num_days)
memberships = CorpMembership.objects.filter(status=True, status_detail__in=["active", "expired"])
if notice.notice_type in ["approve_join", "disapprove_join"]:
memberships = memberships.filter(
approved_denied_dt__year=start_dt.year,
approved_denied_dt__month=start_dt.month,
approved_denied_dt__day=start_dt.day,
renewal=False,
)
elif notice.notice_type in ["approve_renewal", "disapprove_renewal"]:
memberships = memberships.filter(
approved_denied_dt__year=start_dt.year,
approved_denied_dt__month=start_dt.month,
approved_denied_dt__day=start_dt.day,
renewal=True,
)
else: # 'expire'
memberships = memberships.filter(
expiration_dt__year=start_dt.year,
expiration_dt__month=start_dt.month,
expiration_dt__day=start_dt.day,
)
# filter by membership type
if notice.corporate_membership_type:
memberships = memberships.filter(corporate_membership_type=notice.corporate_membership_type)
memberships_count = memberships.count()
if memberships_count > 0:
email.content_type = notice.content_type
global_context = {
"site_display_name": site_display_name,
"site_contact_name": site_contact_name,
"site_contact_email": site_contact_email,
"time_submitted": nowstr,
}
# log notice sent
notice_log = NoticeLog(notice=notice, num_sent=0)
notice_log.save()
notice.log = notice_log
notice.err = ""
for membership in memberships:
try:
num_sent += email_member(notice, membership, global_context)
if memberships_count <= 50:
notice.members_sent.append(membership)
# log record
notice_log_record = NoticeLogRecord(notice_log=notice_log, corp_membership=membership)
notice_log_record.save()
except:
# catch the exception and email
notice.err += traceback.format_exc()
print traceback.format_exc()
if num_sent > 0:
notice_log.num_sent = num_sent
notice_log.save()
return num_sent
def email_member(notice, membership, global_context):
corp_profile = membership.corp_profile
representatives = corp_profile.reps.filter(Q(is_dues_rep=True) | (Q(is_member_rep=True)))
sent = 0
for recipient in representatives:
body = notice.email_content
context = membership.get_field_items()
context["membership"] = membership
context.update(global_context)
context.update({"rep_first_name": recipient.user.first_name})
if membership.expiration_dt:
body = body.replace(
"[expirationdatetime]", time.strftime("%d-%b-%y %I:%M %p", membership.expiration_dt.timetuple())
)
else:
body = body.replace("[expirationdatetime]", "")
context.update(
{
"corporatemembershiptypeid": str(membership.corporate_membership_type.id),
"corporatemembershiptype": membership.corporate_membership_type.name,
"view_link": "%s%s" % (site_url, membership.get_absolute_url()),
"renew_link": "%s%s" % (site_url, membership.get_renewal_url()),
"renewed_individuals_list": render_to_string(
("notification/corp_memb_notice_email/renew_list.html"), {"corp_membership": membership}
),
}
)
body = fieldify(body)
body = "%s <br /><br />%s" % (body, get_footer())
context = Context(context)
template = Template(body)
body = template.render(context)
email.recipient = recipient.user.email
email.subject = notice.subject.replace("(name)", corp_profile.name)
email.body = body
if notice.sender:
email.sender = notice.sender
email.reply_to = notice.sender
if notice.sender_display:
email.sender_display = notice.sender_display
email.send()
sent += 1
if verbosity > 1:
print "To ", email.recipient, email.subject
return sent
def get_footer():
return """
This e-mail was generated by Tendenci® Software -
a web based membership management software solution
www.tendenci.com developed by Schipul - The Web
Marketing Company
"""
exception_str = ""
notices = Notice.objects.filter(status=True, status_detail="active").exclude(notice_time="attimeof")
if notices:
if verbosity > 1:
print "Start sending out notices to members:"
total_notices = 0
total_sent = 0
for notice in notices:
total_notices += 1
total_sent += process_notice(notice)
if hasattr(notice, "err"):
exception_str += notice.err
if total_sent > 0:
processed_notices = [notice for notice in notices if hasattr(notice, "log") and notice.log.num_sent > 0]
email_admins_recap(processed_notices, total_sent)
# if there is any error, notify us
if exception_str:
email_script_errors(exception_str)
if verbosity > 1:
print "Total notice processed: %d" % (total_notices)
print "Total email sent: %d" % (total_sent)
print "Done"
else:
if verbosity > 1:
print "No notices on the site."
def message(request, group_slug, template_name='user_groups/message.html'):
"""
Send a message to the group
"""
from tendenci.core.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 %s members in this group' % num_members)
EventLog.objects.log(instance=email)
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):
verbosity = 1
if 'verbosity' in options:
verbosity = options['verbosity']
from django.conf import settings
from tendenci.addons.memberships.models import Notice, Membership, NoticeLog, NoticeLogRecord
from tendenci.core.base.utils import fieldify
from tendenci.core.emails.models import Email
from tendenci.apps.profiles.models import Profile
from tendenci.core.site_settings.utils import get_setting
site_display_name = get_setting('site', 'global', 'sitedisplayname')
site_contact_name = get_setting('site', 'global', 'sitecontactname')
site_contact_email = get_setting('site', 'global', 'sitecontactemail')
site_url = get_setting('site', 'global', 'siteurl')
corp_replace_str = """
<br /><br />
<font color="#FF0000">
Organizational Members, please contact your company Membership coordinator
to ensure that your membership is being renewed.
</font>
"""
email = Email()
email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email.sender_display = site_display_name
email.reply_to = site_contact_email
now = datetime.now()
nowstr = time.strftime("%d-%b-%y %I:%M %p", now.timetuple())
def email_admins_recap(notices, total_sent):
"""Send admins recap after the notices were processed.
"""
email.recipient = get_admin_emails()
if email.recipient:
template_name = "memberships/notices/email_recap.html"
try:
recap_email_content = render_to_string(template_name, {'notices':notices,
'total_sent':total_sent,
'site_url': site_url,
'site_display_name': site_display_name,
'site_contact_name': site_contact_name,
'site_contact_email': site_contact_email})
email.body = recap_email_content
email.content_type = "html"
email.subject = '%s Membership Notices Distributed' % site_display_name
email.send()
except TemplateDoesNotExist:
pass
def email_script_errors(err_msg):
"""Send error message to us if any.
"""
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 Processing Membership Notices on %s' % site_url
email.send()
def get_script_support_emails():
admins = getattr(settings, 'ADMINS', None)
if admins:
recipients_list = [admin[1] for admin in admins]
return ','.join(recipients_list)
return None
def get_admin_emails():
admin_emails = get_setting('module', 'memberships', 'membershiprecipients').strip()
if admin_emails:
admin_emails = admin_emails.split(',')
if not user.profile.is_superuser_emails:
admin_emails = (get_setting('site', 'global', 'admincontactemail').strip()).split(',')
if admin_emails:
admin_emails = ','.join(admin_emails)
return admin_emails
def process_notice(notice):
notice.members_sent = []
num_sent = 0
if notice.notice_time == 'before':
start_dt = now + timedelta(days=notice.num_days)
else:
start_dt = now - timedelta(days=notice.num_days)
memberships = Membership.objects.active()
if notice.notice_type == 'join':
memberships = memberships.filter(subscribe_dt__year=start_dt.year,
subscribe_dt__month=start_dt.month,
subscribe_dt__day=start_dt.day,
renewal=False)
elif notice.notice_type == 'renew':
memberships = memberships.filter(subscribe_dt__year=start_dt.year,
subscribe_dt__month=start_dt.month,
subscribe_dt__day=start_dt.day,
renewal=True)
else: # 'expire'
memberships = memberships.filter(expire_dt__year=start_dt.year,
expire_dt__month=start_dt.month,
expire_dt__day=start_dt.day)
# filter by membership type
if notice.membership_type:
memberships = memberships.filter(membership_type=notice.membership_type)
if memberships:
email.content_type = notice.content_type
# password
passwd_str = """
If you've forgotten your password or need to reset the auto-generated one,
click <a href="%s%s">here</a> and follow the instructions on the page to
reset your password.
""" % (site_url, reverse('auth_password_reset'))
# notice.email_content = notice.email_content.replace("[password]", passwd_str)
global_context = {'sitedisplayname': site_display_name,
'sitecontactname': site_contact_name,
'sitecontactemail': site_contact_email,
'timesubmitted': nowstr,
'password': passwd_str
}
# log notice sent
notice_log = NoticeLog(notice=notice,
num_sent=0)
notice_log.save()
notice.log = notice_log
notice.err = ''
memberships_count = memberships.count()
for membership in memberships:
try:
email_member(notice, membership, global_context)
if memberships_count <= 50:
notice.members_sent.append(membership)
num_sent += 1
# log record
notice_log_record = NoticeLogRecord(notice_log=notice_log,
membership=membership)
notice_log_record.save()
except:
# catch the exception and email
notice.err += traceback.format_exc()
if num_sent > 0:
notice_log.num_sent = num_sent
notice_log.save()
return num_sent
def email_member(notice, membership, global_context):
user = membership.user
body = notice.email_content
context = membership.entry_items
context.update(global_context)
body = body.replace("[membershiptypeid]", str(membership.membership_type.id))
body = body.replace("[membershiplink]", '%s%s' % (site_url, membership.get_absolute_url()))
# memberships page ------------
memberships_page = "%s%s%s" % \
(site_url, reverse('profile', args=[membership.user]), "#userview-memberships")
body = body.replace("[renewlink]", memberships_page)
if membership.expire_dt:
body = body.replace("[expirationdatetime]",
time.strftime("%d-%b-%y %I:%M %p", membership.expire_dt.timetuple()))
else:
body = body.replace("[expirationdatetime]", '')
# corporate member corp_replace_str
if membership.corporate_membership_id:
body = body.replace("<!--[corporatemembernotice]-->", corp_replace_str)
else:
body = body.replace("<!--[corporatemembernotice]-->", "")
context.update({'membershiptypeid': str(membership.membership_type.id),
'membershiplink': '%s%s' % (site_url, membership.get_absolute_url()),
'renewlink': memberships_page,
'membernumber': membership.member_number,
'membershiptype': membership.membership_type.name,
})
if membership.expire_dt:
context['expirationdatetime'] = time.strftime("%d-%b-%y %I:%M %p",
membership.expire_dt.timetuple())
# corporate member corp_replace_str
if membership.corporate_membership_id:
context['corporatemembernotice'] = corp_replace_str
body = fieldify(body)
body = '%s <br /><br />%s' % (body, get_footer())
context = Context(context)
template = Template(body)
body = template.render(context)
email.recipient = user.email
email.subject = notice.subject.replace('(name)', user.get_full_name())
email.body = body
if notice.sender:
email.sender = notice.sender
email.reply_to = notice.sender
if notice.sender_display:
email.sender_display = notice.sender_display
email.send()
if verbosity > 1:
print 'To ', email.recipient, email.subject
def get_footer():
return """
This e-mail was generated by Tendenci® Software - a
web based membership management software solution
www.tendenci.com developed by Schipul - The Web Marketing Company
"""
exception_str = ""
notices = Notice.objects.filter(status=True, status_detail='active').exclude(notice_time='attimeof')
if notices:
if verbosity > 1:
print "Start sending out notices to members:"
total_notices = 0
total_sent = 0
for notice in notices:
total_notices += 1
total_sent += process_notice(notice)
if hasattr(notice, 'err'):
exception_str += notice.err
if total_sent > 0:
processed_notices = [notice for notice in notices if hasattr(notice, 'log') and notice.log.num_sent>0]
email_admins_recap(processed_notices, total_sent)
# if there is any error, notify us
if exception_str:
email_script_errors(exception_str)
if verbosity > 1:
print 'Total notice processed: %d' % (total_notices)
print 'Total email sent: %d' % (total_sent)
print "Done"
else:
if verbosity > 1:
print "No notices on the site."
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)
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():
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()
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()
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()
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)
# log an event for invoice add
EventLog.objects.log(instance=form)
# redirect to billing form
return redirect('form_entry_payment', invoice.id, invoice.guid)
# default redirect
if form.completion_url:
return HttpResponseRedirect(form.completion_url)
return redirect("form_sent", form.slug)
# set form's template to default if no template or template doesn't exist
if not form.template or not template_exists(form.template):
form.template = "default.html"
context = {
"form": form,
"form_for_form": form_for_form,
'form_template': form.template,
}
return render_to_response(template, context, RequestContext(request))
def handle(self, *args, **options):
verbosity = 1
if 'verbosity' in options:
verbosity = options['verbosity']
# first test if we have notices set up
from tendenci.addons.corporate_memberships.models import Notice
if not Notice.objects.filter(status=True,
status_detail='active'
).exclude(
notice_time='attimeof'
).exists():
if verbosity > 1:
print('No notices set up...existing...')
# no active notices to process. stop here
return
from tendenci.addons.corporate_memberships.models import (
CorpMembership,
NoticeLog,
NoticeLogRecord)
from tendenci.core.base.utils import fieldify
from tendenci.core.emails.models import Email
from tendenci.core.site_settings.utils import get_setting
site_display_name = get_setting('site', 'global', 'sitedisplayname')
site_contact_name = get_setting('site', 'global', 'sitecontactname')
site_contact_email = get_setting('site', 'global', 'sitecontactemail')
site_url = get_setting('site', 'global', 'siteurl')
email = Email()
email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email.sender_display = site_display_name
email.reply_to = site_contact_email
now = datetime.now()
nowstr = time.strftime("%d-%b-%y %I:%M %p", now.timetuple())
def email_admins_recap(notices, total_sent):
"""Send admins recap after the notices were processed.
"""
email.recipient = get_admin_emails()
if email.recipient:
template_name = "corporate_memberships/notices/email_recap.html"
try:
recap_email_content = render_to_string(
template_name,
{'notices': notices,
'total_sent': total_sent,
'site_url': site_url,
'site_display_name': site_display_name,
'site_contact_name': site_contact_name,
'site_contact_email': site_contact_email})
email.body = recap_email_content
email.content_type = "html"
email.subject = '%s Corporate Membership Notices Distributed' % (
site_display_name)
email.send()
except TemplateDoesNotExist:
pass
def email_script_errors(err_msg):
"""Send error message to us if any.
"""
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 Processing Corporate Membership Notices on %s' % (
site_url)
email.send()
def get_script_support_emails():
admins = getattr(settings, 'ADMINS', None)
if admins:
recipients_list = [admin[1] for admin in admins]
return ','.join(recipients_list)
return None
def get_admin_emails():
admin_emails = get_setting('module', 'corporate_memberships',
'corporatemembershiprecipients').strip()
if admin_emails:
admin_emails = admin_emails.split(',')
if not admin_emails:
admin_emails = (get_setting('site', 'global',
'admincontactemail'
).strip()).split(',')
if admin_emails:
admin_emails = ','.join(admin_emails)
return admin_emails
def process_notice(notice):
notice.members_sent = []
num_sent = 0
if notice.notice_time == 'before':
start_dt = now + timedelta(days=notice.num_days)
else:
start_dt = now - timedelta(days=notice.num_days)
if notice.notice_type == 'disapprove':
status_detail_list = ['inactive']
else:
status_detail_list = ['active', 'expired']
memberships = CorpMembership.objects.filter(
status=True,
status_detail__in=status_detail_list
)
if notice.notice_type in ['approve_join', 'disapprove_join'
'approve_renewal', 'disapprove_renewal']:
filters = {'approved_denied_dt__year': start_dt.year,
'approved_denied_dt__month': start_dt.month,
'approved_denied_dt__day': start_dt.day,
'renewal': False,
'approved': True
}
if notice.notice_type in ['approve_renewal',
'disapprove_renewal']:
filters.update({'renewal': True})
if notice.notice_type in ['disapprove_join',
'disapprove_renewal']:
filters.update({'approved': False})
memberships = memberships.filter(**filters)
else: # 'expire'
memberships = memberships.filter(
expiration_dt__year=start_dt.year,
expiration_dt__month=start_dt.month,
expiration_dt__day=start_dt.day)
# filter by membership type
if notice.corporate_membership_type:
memberships = memberships.filter(
corporate_membership_type=notice.corporate_membership_type)
memberships_count = memberships.count()
if memberships_count > 0:
email.content_type = notice.content_type
global_context = {'site_display_name': site_display_name,
'site_contact_name': site_contact_name,
'site_contact_email': site_contact_email,
'time_submitted': nowstr,
}
# log notice sent
notice_log = NoticeLog(notice=notice,
num_sent=0)
notice_log.save()
notice.log = notice_log
notice.err = ''
for membership in memberships:
try:
num_sent += email_member(notice, membership, global_context)
if memberships_count <= 50:
notice.members_sent.append(membership)
# log record
notice_log_record = NoticeLogRecord(
notice_log=notice_log,
corp_membership=membership)
notice_log_record.save()
except:
# catch the exception and email
notice.err += traceback.format_exc()
print traceback.format_exc()
if num_sent > 0:
notice_log.num_sent = num_sent
notice_log.save()
return num_sent
def email_member(notice, membership, global_context):
corp_profile = membership.corp_profile
representatives = corp_profile.reps.filter(Q(is_dues_rep=True)|(Q(is_member_rep=True)))
sent = 0
for recipient in representatives:
body = notice.email_content
context = membership.get_field_items()
context['membership'] = membership
context.update(global_context)
context.update({
'rep_first_name': recipient.user.first_name,
})
if membership.expiration_dt:
body = body.replace("[expirationdatetime]",
time.strftime(
"%d-%b-%y %I:%M %p",
membership.expiration_dt.timetuple()))
else:
body = body.replace("[expirationdatetime]", '')
context.update({
'corporatemembershiptypeid': str(membership.corporate_membership_type.id),
'corporatemembershiptype': membership.corporate_membership_type.name,
'view_link': "%s%s" % (site_url, membership.get_absolute_url()),
'renew_link': "%s%s" % (site_url, membership.get_renewal_url()),
'renewed_individuals_list': render_to_string(('notification/corp_memb_notice_email/renew_list.html'),
{'corp_membership': membership, }),
})
body = fieldify(body)
body = '%s <br /><br />%s' % (body, get_footer())
context = Context(context)
template = Template(body)
body = template.render(context)
email.recipient = recipient.user.email
subject = notice.subject.replace('(name)',
corp_profile.name)
template = Template(subject)
subject = template.render(context)
email.subject = subject
email.body = body
if notice.sender:
email.sender = notice.sender
email.reply_to = notice.sender
if notice.sender_display:
email.sender_display = notice.sender_display
email.send()
sent += 1
if verbosity > 1:
print 'To ', email.recipient, email.subject
return sent
def get_footer():
return """
This e-mail was generated by Tendenci® Software -
a web based membership management software solution
www.tendenci.com developed by Schipul - The Web
Marketing Company
"""
exception_str = ""
notices = Notice.objects.filter(status=True, status_detail='active'
).exclude(notice_time='attimeof')
if notices:
if verbosity > 1:
print "Start sending out notices to members:"
total_notices = 0
total_sent = 0
for notice in notices:
total_notices += 1
total_sent += process_notice(notice)
if hasattr(notice, 'err'):
exception_str += notice.err
if total_sent > 0:
processed_notices = [notice for notice in notices if hasattr(
notice, 'log'
) and notice.log.num_sent > 0]
email_admins_recap(processed_notices, total_sent)
# if there is any error, notify us
if exception_str:
email_script_errors(exception_str)
if verbosity > 1:
print 'Total notice processed: %d' % (total_notices)
print 'Total email sent: %d' % (total_sent)
print "Done"
else:
if verbosity > 1:
print "No notices on the site."
class RecurringPaymentEmailNotices(object):
def __init__(self):
self.site_display_name = get_setting('site', 'global', 'sitedisplayname')
self.site_contact_name = get_setting('site', 'global', 'sitecontactname')
self.site_contact_email = get_setting('site', 'global', 'sitecontactemail')
self.reply_to_email = get_setting('module', 'payments', 'paymentrecipients')
if not self.reply_to_email:
self.reply_to_email = self.site_contact_email
self.site_url = get_setting('site', 'global', 'siteurl')
self.email = Email()
self.email.sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
self.email.sender_display = self.site_display_name
self.email.reply_to = self.reply_to_email
self.admin_emails = self.get_admin_emails()
def get_admin_emails(self):
payment_admins = get_setting('module', 'payments', 'paymentrecipients')
if payment_admins:
payment_admins = payment_admins.split(',')
admin_emails = payment_admins
else:
admin_emails = (get_setting('site', 'global', 'admincontactemail')).split(',')
if admin_emails:
admin_emails = ','.join(admin_emails)
return admin_emails
def get_script_support_emails(self):
admins = getattr(settings, 'ADMINS', None)
if admins:
recipients_list = [admin[1] for admin in admins]
return ','.join(recipients_list)
return None
def email_script_support_transaction_error(self, payment_transaction):
"""if there is an error other than transaction not being approved, notify us.
"""
self.email.recipient = self.get_script_support_emails()
if self.email.recipient:
template_name = "recurring_payments/email_script_support_transaction.html"
try:
email_content = render_to_string(template_name,
{'pt':payment_transaction,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
self.email.priority = 1
self.email.subject = _('Recurring payment transaction error on %(dname)s' % {
'dname':self.site_display_name})
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_transaction_result(self, payment_transaction, success=True):
"""Send admins the result after the transaction is processed.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_transaction.html"
user_in_texas = False
if payment_transaction.payment.state:
if payment_transaction.payment.state.lower() in ['texas', 'tx']:
user_in_texas = True
try:
email_content = render_to_string(template_name,
{'pt':payment_transaction,
'site_display_name': self.site_display_name,
'site_url': self.site_url,
'user_in_texas': user_in_texas
})
self.email.body = email_content
self.email.content_type = "html"
if not success:
self.email.subject = _('Recurring payment transaction failed on %(dname)s' % {
'dname': self.site_display_name})
self.email.priority = 1
else:
self.email.subject = _('Recurring payment transaction processed on %(dname)s' % {
'dname': self.site_display_name})
self.email.send()
except TemplateDoesNotExist:
pass
def email_customer_transaction_result(self, payment_transaction):
"""Send customer an email after the transaction is processed.
"""
self.email.recipient = payment_transaction.recurring_payment.user.email
if self.email.recipient:
template_name = "recurring_payments/email_customer_transaction.html"
try:
email_content = render_to_string(template_name,
{'pt':payment_transaction,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
if payment_transaction.status:
self.email.subject = _('Payment received ')
else:
self.email.subject = _('Payment failed ')
self.email.subject = _("%(subj)s for %(desc)s " % {
'subj': self.email.subject,
'desc': payment_transaction.recurring_payment.description})
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_no_payment_profile(self, recurring_payment):
"""Notify admin that payment method hasn't been setup yet for this recurring payment entry.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_no_payment_profile.html"
try:
email_content = render_to_string(template_name,
{'rp':recurring_payment,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = _('Payment method not setup for %(rp)s on %(dname)s' % {
'rp': recurring_payment ,
'dname': self.site_display_name})
self.email.send()
except TemplateDoesNotExist:
pass
def email_customer_no_payment_profile(self, recurring_payment):
"""Notify customer that payment method hasn't been setup yet for this recurring payment entry.
"""
self.email.recipient = recurring_payment.user.email
if self.email.recipient:
template_name = "recurring_payments/email_customer_no_payment_profile.html"
try:
email_content = render_to_string(template_name,
{'rp':recurring_payment,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = _('Please update your payment method for %(rp)s on %(dname)s' % {
'rp': recurring_payment.description,
'dname': self.site_display_name})
self.email.send()
except TemplateDoesNotExist:
pass
def email_admins_account_disabled(self, recurring_payment, user_by):
"""Notify admin that the recurring payment account is disabled.
"""
self.email.recipient = self.admin_emails
if self.email.recipient:
template_name = "recurring_payments/email_admins_account_disabled.html"
try:
email_content = render_to_string(template_name,
{'rp':recurring_payment,
'user_by': user_by,
'site_display_name': self.site_display_name,
'site_url': self.site_url
})
self.email.body = email_content
self.email.content_type = "html"
self.email.subject = _('Recurring Payment Account (ID:%(id)d) Disabled by %(usr)s on %(dname)s' % {
'id':recurring_payment.id,
'usr' : user_by,
'dname': self.site_display_name})
self.email.send()
except TemplateDoesNotExist:
pass
def process_export(identifier, user_id):
field_list = [
'guid',
'slug',
'timezone',
'headline',
'summary',
'body',
'source',
'first_name',
'last_name',
'phone',
'fax',
'email',
'website',
'release_dt',
'syndicate',
'featured',
'design_notes',
'tags',
'enclosure_url',
'enclosure_type',
'enclosure_length',
'not_official_content',
'entity',
]
identifier = identifier or int(ttime.time())
file_name_temp = 'export/articles/%s_temp.csv' % (identifier)
with default_storage.open(file_name_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_list)
articles = Article.objects.filter(status_detail='active')
for article in articles:
items_list = []
for field_name in field_list:
item = getattr(article, field_name)
if isinstance(item, datetime):
item = item.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(item, date):
item = item.strftime('%Y-%m-%d')
elif isinstance(item, time):
item = item.strftime('%H:%M:%S')
elif isinstance(item, basestring):
item = item.encode("utf-8")
item = smart_str(item).decode('utf-8')
items_list.append(item)
csv_writer.writerow(items_list)
# rename the file name
file_name = 'export/articles/%s.csv' % identifier
default_storage.save(file_name, default_storage.open(file_name_temp, 'rb'))
# delete the temp file
default_storage.delete(file_name_temp)
# notify user that export is ready to download
[user] = User.objects.filter(pk=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('article.export_download', args=[identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name
}
subject = render_to_string(
'articles/notices/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string('articles/notices/export_ready_body.html',
parms)
email = Email(recipient=user.email, subject=subject, body=body)
email.send()
def process_export(export_fields='all_fields', identifier=u'', user_id=0):
from tendenci.core.perms.models import TendenciBaseModel
if export_fields == 'main_fields':
user_field_list = [
'username',
'first_name',
'last_name',
'email']
profile_field_list = [
'salutation',
'initials',
'display_name',
'company',
'department',
'position_title',
'sex',
'address',
'address2',
'city',
'state',
'zipcode',
'country',
'phone',
'phone2',
'fax',
'work_phone',
'home_phone',
'mobile_phone',
'url',
'url2',
'dob',
'status_detail']
else:
# base ------------
base_field_list = [
smart_str(field.name) for field in TendenciBaseModel._meta.fields
if not field.__class__ == AutoField]
# user ------------
user_field_list = [
smart_str(field.name) for field in User._meta.fields
if not field.__class__ == AutoField]
user_field_list.remove('password')
# profile ---------
profile_field_list = [
smart_str(field.name) for field in Profile._meta.fields
if not field.__class__ == AutoField]
profile_field_list = [
name for name in profile_field_list
if not name in base_field_list]
profile_field_list.remove('guid')
profile_field_list.remove('user')
# append base fields at the end
field_list = user_field_list + profile_field_list
identifier = identifier or int(ttime.time())
file_name_temp = 'export/profiles/%s_temp.csv' % identifier
with default_storage.open(file_name_temp, 'wb') as csvfile:
csv_writer = UnicodeWriter(csvfile, encoding='utf-8')
csv_writer.writerow(field_list)
profiles = Profile.objects.all()
for profile in profiles:
p_user = profile.user
items_list = []
for field_name in field_list:
if field_name in profile_field_list:
item = getattr(profile, field_name)
elif field_name in user_field_list:
item = getattr(p_user, field_name)
else:
item = ''
if item:
if isinstance(item, datetime):
item = item.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(item, date):
item = item.strftime('%Y-%m-%d')
elif isinstance(item, time):
item = item.strftime('%H:%M:%S')
elif isinstance(item, basestring):
item = item.encode("utf-8")
item = smart_str(item).decode('utf-8')
items_list.append(item)
csv_writer.writerow(items_list)
# rename the file name
file_name = 'export/profiles/%s.csv' % identifier
default_storage.save(file_name, default_storage.open(file_name_temp, 'rb'))
# delete the temp file
default_storage.delete(file_name_temp)
# notify user that export is ready to download
[user] = User.objects.filter(pk=user_id)[:1] or [None]
if user and user.email:
download_url = reverse('profile.export_download', args=[identifier])
site_url = get_setting('site', 'global', 'siteurl')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
parms = {
'download_url': download_url,
'user': user,
'site_url': site_url,
'site_display_name': site_display_name,
'export_fields': export_fields}
subject = render_to_string(
'profiles/notices/export_ready_subject.html', parms)
subject = subject.strip('\n').strip('\r')
body = render_to_string(
'profiles/notices/export_ready_body.html', parms)
email = Email(
recipient=user.email,
subject=subject,
body=body)
email.send()
def message(request, group_slug, template_name='user_groups/message.html'):
"""
Send a message to the group
"""
from tendenci.core.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
})
