def conn(self):
if not self._conn:
self._conn = SESConnection(
aws_access_key_id=self.config['access_key'],
aws_secret_access_key=self.config['secret_key'],
)
return self._conn
def emit(self, record):
"""
Emit a record.
Format the record and send it to the specified addressees.
"""
client = SESConnection(self.aws_key, self.aws_secret)
message = MIMEMultipart('alternative')
message.set_charset('UTF-8')
message['Subject'] = self._encode_str(self.getSubject(record))
message['From'] = self._encode_str(self.fromaddr)
message['To'] = self._convert_to_strings(self.toaddrs)
from email.utils import formatdate
body = self.format(record)
body = "Date: {0}\r\n\r\n {1}".format(formatdate(), body)
message.attach(MIMEText(self._encode_str(body), 'plain'))
return client.send_raw_email(message.as_string(),
self.fromaddr,
destinations=self.toaddrs)
def handle(self, *args, **options):
verbosity = options.get('verbosity', 0)
add_email = options.get('add', False)
delete_email = options.get('delete', False)
list_emails = options.get('list', False)
access_key_id = getattr(settings, 'AWS_ACCESS_KEY_ID', None)
access_key = getattr(settings, 'AWS_SECRET_ACCESS_KEY', None)
api_endpoint = getattr(settings, 'AWS_SES_API_HOST',
'%s.%s' % (
SESConnection.DefaultRegionName,
SESConnection.DefaultRegionEndpoint))
connection = SESConnection(
aws_access_key_id=access_key_id,
aws_secret_access_key=access_key,
host=api_endpoint,
)
if add_email:
if verbosity != '0':
print "Adding email: %s" % add_email
connection.verify_email_address(add_email)
elif delete_email:
if verbosity != '0':
print "Removing email: %s" % delete_email
connection.delete_verified_email_address(delete_email)
elif list_emails:
if verbosity != '0':
print "Fetching list of verified emails:"
response = connection.list_verified_email_addresses()
emails = response['ListVerifiedEmailAddressesResponse']['ListVerifiedEmailAddressesResult']['VerifiedEmailAddresses']
for email in emails:
print email
def handle(self, *args, **options):
verbosity = options.get('verbosity', 0)
add_email = options.get('add', False)
delete_email = options.get('delete', False)
list_emails = options.get('list', False)
access_key_id = settings.ACCESS_KEY
access_key = settings.SECRET_KEY
region = RegionInfo(
name=settings.AWS_SES_REGION_NAME,
endpoint=settings.AWS_SES_REGION_ENDPOINT)
connection = SESConnection(
aws_access_key_id=access_key_id,
aws_secret_access_key=access_key,
region=region)
if add_email:
if verbosity != '0':
print "Adding email: %s" % add_email
connection.verify_email_address(add_email)
elif delete_email:
if verbosity != '0':
print "Removing email: %s" % delete_email
connection.delete_verified_email_address(delete_email)
elif list_emails:
if verbosity != '0':
print "Fetching list of verified emails:"
response = connection.list_verified_email_addresses()
emails = response['ListVerifiedEmailAddressesResponse'][
'ListVerifiedEmailAddressesResult']['VerifiedEmailAddresses']
for email in emails:
print email
def __init__(self, aws_access_key, aws_secret_key):
try:
self.ses_conn = SESConnection(aws_access_key_id=aws_access_key,
aws_secret_access_key=aws_secret_key)
except:
print "SES Connection was failed !!"
exit()
def ses_email(config, to_address, subject, body):
connection = SESConnection(
aws_access_key_id=config['AWS_ACCESS_KEY_ID'],
aws_secret_access_key=config['AWS_SECRET_ACCESS_KEY_ID'])
from_address = '"SolutionNet" <{0}>'.format(config['FROM_EMAIL_ADDRESS'])
connection.send_email(from_address, str(subject), str(escape(body)),
str(to_address))
def ses_email(config, to_address, subject, body):
connection = SESConnection(
aws_access_key_id=config['AWS_ACCESS_KEY_ID'],
aws_secret_access_key=config['AWS_SECRET_ACCESS_KEY'],
region=next(i for i in regions() if i.name == config['AWS_REGION']))
from_address = '"SolutionNet" <{0}>'.format(config['FROM_EMAIL_ADDRESS'])
connection.send_email(from_address, str(subject), str(body),
str(to_address))
def dashboard(request):
"""
Graph SES send statistics over time.
"""
cache_key = 'vhash:django_ses_stats'
cached_view = cache.get(cache_key)
if cached_view:
return cached_view
region = RegionInfo(name=getattr(settings, 'AWS_SES_REGION_NAME',
SESConnection.DefaultRegionName),
endpoint=getattr(settings, 'AWS_SES_REGION_ENDPOINT',
SESConnection.DefaultRegionEndpoint))
ses_conn = SESConnection(
aws_access_key_id=getattr(settings, 'AWS_ACCESS_KEY_ID', None),
aws_secret_access_key=getattr(settings, 'AWS_SECRET_ACCESS_KEY', None),
region=region)
quota_dict = ses_conn.get_send_quota()
verified_emails_dict = ses_conn.list_verified_email_addresses()
stats = ses_conn.get_send_statistics()
quota = quota_parse(quota_dict)
verified_emails = emails_parse(verified_emails_dict)
ordered_data = stats_to_list(stats)
summary = sum_stats(ordered_data)
extra_context = {
'title':
'SES Statistics',
'datapoints':
ordered_data,
'24hour_quota':
quota['Max24HourSend'],
'24hour_sent':
quota['SentLast24Hours'],
'24hour_remaining':
float(quota['Max24HourSend']) - float(quota['SentLast24Hours']),
'persecond_rate':
quota['MaxSendRate'],
'verified_emails':
verified_emails,
'summary':
summary,
'access_key':
ses_conn.gs_access_key_id,
'local_time':
True if pytz else False,
}
response = render_to_response('django_ses/send_stats.html',
extra_context,
context_instance=RequestContext(request))
cache.set(cache_key, response, 60 * 15) # Cache for 15 minutes
return response
def dashboard(request):
"""
Graph SES send statistics over time.
"""
cache_key = 'vhash:django_ses_stats'
cached_view = cache.get(cache_key)
if cached_view:
return cached_view
region = RegionInfo(name=settings.AWS_SES_REGION_NAME,
endpoint=settings.AWS_SES_REGION_ENDPOINT)
ses_conn = SESConnection(
aws_access_key_id=settings.ACCESS_KEY,
aws_secret_access_key=settings.SECRET_KEY,
region=region,
proxy=settings.AWS_SES_PROXY,
proxy_port=settings.AWS_SES_PROXY_PORT,
)
quota_dict = ses_conn.get_send_quota()
verified_emails_dict = ses_conn.list_verified_email_addresses()
stats = ses_conn.get_send_statistics()
quota = quota_parse(quota_dict)
verified_emails = emails_parse(verified_emails_dict)
ordered_data = stats_to_list(stats)
summary = sum_stats(ordered_data)
extra_context = {
'title':
'SES Statistics',
'datapoints':
ordered_data,
'24hour_quota':
quota['Max24HourSend'],
'24hour_sent':
quota['SentLast24Hours'],
'24hour_remaining':
float(quota['Max24HourSend']) - float(quota['SentLast24Hours']),
'persecond_rate':
quota['MaxSendRate'],
'verified_emails':
verified_emails,
'summary':
summary,
'access_key':
ses_conn.gs_access_key_id,
'local_time':
True,
}
response = render(request, 'django_ses/send_stats.html', extra_context)
cache.set(cache_key, response, 60 * 15) # Cache for 15 minutes
return response
def send_mail(msg):
global access_key
global secret_key
client = SESConnection(
aws_access_key_id=access_key, aws_secret_access_key=secret_key)
senders = msg["From"].split(",")
recipients = msg["To"].split(',')
for sender in senders:
client.send_raw_email(msg.as_string(), sender, recipients)
client.close()
def send_ses(self, sender_from, recipients, body):
# SES Connection create
aws_access_key = EXTERNAL_CONFIG['aws_access_key']
aws_secret_key = EXTERNAL_CONFIG['aws_secret_key']
from boto.ses import SESConnection
ses_conn = SESConnection(aws_access_key, aws_secret_key)
ret = ses_conn.send_raw_email(sender_from, body, destinations=[])
current_app.logger.debug('sent mail to %s by SES' % (str(recipients),))
return ret
def __init__(self, source, to_addresses, subject, **kw):
self.ses = SESConnection()
self._source = source
self._to_addresses = to_addresses
self._cc_addresses = None
self._bcc_addresses = None
self.subject = subject
self.text = None
self.html = None
self.attachments = []
def connect_ses(aws_access_key_id=None, aws_secret_access_key=None, **kwargs):
"""
:type aws_access_key_id: string
:param aws_access_key_id: Your AWS Access Key ID
:type aws_secret_access_key: string
:param aws_secret_access_key: Your AWS Secret Access Key
:rtype: :class:`boto.ses.SESConnection`
:return: A connection to Amazon's SES
"""
from boto.ses import SESConnection
return SESConnection(aws_access_key_id, aws_secret_access_key, **kwargs)
def send_invite(modeladmin, request, queryset):
for r in queryset:
h = hashlib.md5("%s%sfunkyfresh" % (request.user.id, r.email))
i = Invite.objects.create(owner=request.user,
email=r.email,
code=h.hexdigest())
r.delete()
c = SESConnection(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
send_mail(
"[muxlist] You're invited!",
render_to_string('email/invite.html', {
'hostname': HOSTNAME,
'invite': i
}), SERVER_EMAIL, [i.email])
def open(self):
"""Create a connection to the AWS API server. This can be reused for
sending multiple emails.
"""
if self.connection:
return False
try:
self.connection = SESConnection(
aws_access_key_id=self._access_key_id,
aws_secret_access_key=self._access_key)
except:
if not self.fail_silently:
raise
class AmazonSMTPServer(smtpd.SMTPServer):
amazonSES = SESConnection()
def process_message(self, peer, mailfrom, rcpttos, data):
if 'False' in rcpttos:
logging.info('No recipient email')
return
data = email.message_from_string(data)
# Amazon SES don't support 'Organization' header, which is created
# by email_template module
if 'Organization' in data:
del data['Organization']
data = data.as_string()
result = self.amazonSES.send_raw_email(mailfrom, data, rcpttos)
logging.info('Email to %s sent' % rcpttos)
def get_boto_ses_connection():
"""
Shortcut for instantiating and returning a boto SESConnection object.
:rtype: boto.ses.SESConnection
:returns: A boto SESConnection object, from which email sending is done.
"""
access_key_id = getattr(settings, 'AWS_ACCESS_KEY_ID', None)
access_key = getattr(settings, 'AWS_SECRET_ACCESS_KEY', None)
api_endpoint = getattr(settings, 'AWS_SES_API_HOST',
SESConnection.DefaultHost)
return SESConnection(
aws_access_key_id=access_key_id,
aws_secret_access_key=access_key,
host=api_endpoint,
)
def handle(self, *args, **options):
verbosity = options.get('verbosity', 0)
add_email = options.get('add', False)
delete_email = options.get('delete', False)
list_emails = options.get('list', False)
access_key_id = settings.ACCESS_KEY
access_key = settings.SECRET_KEY
region = RegionInfo(
name=settings.AWS_SES_REGION_NAME,
endpoint=settings.AWS_SES_REGION_ENDPOINT)
proxy = settings.AWS_SES_PROXY
proxy_port = settings.AWS_SES_PROXY_PORT
proxy_user = settings.AWS_SES_PROXY_USER
proxy_pass = settings.AWS_SES_PROXY_PASS
connection = SESConnection(
aws_access_key_id=access_key_id,
aws_secret_access_key=access_key,
region=region,
proxy=proxy,
proxy_port=proxy_port,
proxy_user=proxy_user,
proxy_pass=proxy_pass,
)
if add_email:
if verbosity != '0':
print("Adding email: " + add_email)
connection.verify_email_address(add_email)
elif delete_email:
if verbosity != '0':
print("Removing email: " + delete_email)
connection.delete_verified_email_address(delete_email)
elif list_emails:
if verbosity != '0':
print("Fetching list of verified emails:")
response = connection.list_verified_email_addresses()
emails = response['ListVerifiedEmailAddressesResponse'][
'ListVerifiedEmailAddressesResult']['VerifiedEmailAddresses']
for email in emails:
print(email)
def handle(self, *args, **options):
connection = SESConnection(
aws_access_key_id=settings.ACCESS_KEY,
aws_secret_access_key=settings.SECRET_KEY,
proxy=settings.AWS_SES_PROXY,
proxy_port=settings.AWS_SES_PROXY_PORT,
proxy_user=settings.AWS_SES_PROXY_USER,
proxy_pass=settings.AWS_SES_PROXY_PASS,
)
stats = connection.get_send_statistics()
data_points = stats_to_list(stats, localize=False)
stats_dict = defaultdict(stat_factory)
for data in data_points:
attempts = int(data['DeliveryAttempts'])
bounces = int(data['Bounces'])
complaints = int(data['Complaints'])
rejects = int(data['Rejects'])
date = data['Timestamp'].split('T')[0]
stats_dict[date]['delivery_attempts'] += attempts
stats_dict[date]['bounces'] += bounces
stats_dict[date]['complaints'] += complaints
stats_dict[date]['rejects'] += rejects
for k, v in stats_dict.items():
stat, created = SESStat.objects.get_or_create(
date=k,
defaults={
'delivery_attempts': v['delivery_attempts'],
'bounces': v['bounces'],
'complaints': v['complaints'],
'rejects': v['rejects'],
})
# If statistic is not new, modify data if values are different
if not created and stat.delivery_attempts != v['delivery_attempts']:
stat.delivery_attempts = v['delivery_attempts']
stat.bounces = v['bounces']
stat.complaints = v['complaints']
stat.rejects = v['rejects']
stat.save()
def open(self):
"""Create a connection to the AWS API server. This can be reused for
sending multiple emails.
"""
if self.connection:
return False
try:
self.connection = SESConnection(
aws_access_key_id=self._access_key_id,
aws_secret_access_key=self._access_key,
region=self._region,
proxy=self._proxy,
proxy_port=self._proxy_port,
proxy_user=self._proxy_user,
proxy_pass=self._proxy_pass,
)
except Exception:
if not self.fail_silently:
raise
def send_email(fromaddr, toaddrs, subject, txtdata):
from boto.ses import SESConnection
connection = SESConnection(aws_access_key_id=keys["AWS_ACCESS_KEY"],
aws_secret_access_key=keys["AWS_SECRET_KEY"])
connection.send_email(fromaddr, subject, txtdata, toaddrs)
"""
import mimetypes
from email import encoders
from email.utils import COMMASPACE
from email.mime.multipart import MIMEMultipart
from email.mime.audio import MIMEAudio
from email.mime.base import MIMEBase
from email.mime.image import MIMEImage
from email.mime.text import MIMEText
from boto.ses import SESConnection
AWS_ACCESS_KEY = 'PUT ACCESS KEY HERE'
AWS_SECRET_KEY = 'PUT SECRET KEY HERE'
connection = SESConnection(AWS_ACCESS_KEY, AWS_SECRET_KEY)
class SESMessage(object):
"""
Usage:
msg = SESMessage('*****@*****.**', '*****@*****.**', 'The subject')
msg.text = 'Text body'
msg.html = 'HTML body'
msg.send()
"""
def __init__(self, source, to_addresses, subject, **kw):
self.ses = connection
def mailsender(request):
mail = request.FILES[u"file"].read()
to = request.GET["to"]
#split headers
i = mail.find("\n\n")
headers, mail = mail[:i], mail[i:]
headers = headers.split("\n")
allowed = {"MIME-Version", "Message-ID", "In-Reply-To", "Content-Type",
"Date", "Subject", "From", "To", "Bcc", "Cc", "References"}
from_ = None
h = []
i=0
while i<len(headers):
add = False
header = headers[i][:headers[i].find(":")]
if header in allowed:
add = True
if header == "From":
from_ = headers[i][headers[i].find(":")+1:].strip()
while True:
if add:
h.append(headers[i])
i += 1
if i>=len(headers) or headers[i][0] not in " \t":
break
mail = "\n".join(h) + mail
#find from email
i = from_.find("<")
if i != -1:
from_ = from_[i+1:]
from_ = from_[:from_.find(">")]
#logger.info("headers: %s", str(headers))
#logger.info("h: %s", str(h))
logger.info("Mail from %s to %s recieved", from_, to)
# Only allow sending from altekamereren domains and registered users.
if not from_.endswith("@altekamereren.org") \
and not from_.endswith("@altekamereren.com") \
and User.objects.filter(email=from_).exists():
logger.info("Sender not accepted.")
return HttpResponse(status=403)
to = to.replace(u"flojt", u"flöjt")
reciever = to.split("@")[0]
if reciever in ak.sections:
user_emails = [user.email for user in User.objects.filter(
instrument__in=ak.section_to_short_instruments[reciever],
is_active=True)]
logger.info("Sending to section %s: %s", to, str(user_emails))
elif reciever == u"infolistan":
reciever = [user.email for user in User.objects.filter(is_active=True)]
logger.info("Sending to infolistan: %s", str(reciever))
else:
logger.info("List not accepted.")
return HttpResponse(status=400)
from django.conf import settings
from boto.ses import SESConnection
from boto.exception import BotoServerError
access_key_id = getattr(settings, 'AWS_ACCESS_KEY_ID', None)
access_key = getattr(settings, 'AWS_SECRET_ACCESS_KEY', None)
api_endpoint = getattr(settings, 'AWS_SES_API_HOST',
SESConnection.DefaultHost)
connection = SESConnection(
aws_access_key_id=access_key_id,
aws_secret_access_key=access_key,
host=api_endpoint,
)
if not user_emails:
return HttpResponse(status=400)
try:
connection.send_raw_email(mail, settings.ADMINS[0][1], user_emails)
except BotoServerError as e:
i = e.body.find("<Message>")
message = e.body[i+len("<Message>"):]
message = message[:message.find("</Message>")]
if message == "Email address is not verified.":
if MailVerificationSent.objects.filter(email=from_,
sent__gte=datetime.datetime.now() - datetime.timedelta(days=1)
).exists():
connection.verify_email_address(from_)
logger.error("Sending verify mail to: %s", from_)
MailVerificationSent(email=from_).save()
else:
logger.error("Verify mail already sent today: %s", from_)
return HttpResponse(status=444)
else:
raise
return HttpResponse()
def startup(self):
self.connection = SESConnection(aws_access_key_id=self.id,
aws_secret_access_key=self.key,
host=self.host)
def get_client(self):
if not self.client:
self.client = SESConnection(self.aws_key, self.aws_secret)
return self.client
