def send_mail_via_smtp_(config, payload):
"""
Send email via SMTP
:param config:
:param payload:
:return:
"""
mailer_config = {
'transport': {
'use': 'smtp',
'host': config['host'],
'username': config['username'],
'password': config['password'],
'tls': config['encryption'],
'port': config['port']
}
}
mailer = Mailer(mailer_config)
mailer.start()
message = Message(author=payload['from'], to=payload['to'])
message.subject = payload['subject']
message.plain = strip_tags(payload['html'])
message.rich = payload['html']
mailer.send(message)
mailer.stop()
def sendMail(mail):
try:
message = Message(author="*****@*****.**", to=mail)
# mail subject, obviously
message.subject = "Subject"
# plain text variant:
message.plain = "Please view this mail with html enabled."
# when pressing "reply", send mail to:
message.reply = "*****@*****.**"
# HTML variant:
message.rich = """
<h1>Header</h1>
<p>some text</p>
"""
message.attach(name='path-to-attachment.pdf')
mailer.send(message)
print('successfull sent mail to ' + mail)
return True
except:
print('There was an error for mail ' + mail + ", skipping this.")
return False
def send_report_mail(plain_text, settings):
"""Send anomalies report by email
Arguments:
plain_text {string} -- Report body in plain text
settings (dict) -- Settings from the class Config.Smtp
Returns:
"""
mailer = Mailer({
'manager.use': 'futures',
'transport.use': 'smtp',
'transport.host': settings['host'],
'transport.tls': settings['ssl'],
'transport.debug': False,
'transport.username': settings['username'],
'transport.password': settings['password'],
'transport.max_messages_per_connection': 5
})
mailer.start()
message = Message(author=settings['mailfrom'], to=settings['mailto'])
message.subject = settings['subject']
message.plain = plain_text
mailer.send(message)
mailer.stop()
return True
def send_email_task_smtp(payload, smtp_config, headers=None):
mailer_config = {
'transport': {
'use': 'smtp',
'host': smtp_config['host'],
'username': smtp_config['username'],
'password': smtp_config['password'],
'tls': smtp_config['encryption'],
'port': smtp_config['port']
}
}
try:
mailer = Mailer(mailer_config)
mailer.start()
message = Message(author=payload['from'], to=payload['to'])
message.subject = payload['subject']
message.plain = strip_tags(payload['html'])
message.rich = payload['html']
if payload['attachments'] is not None:
for attachment in payload['attachments']:
message.attach(name=attachment)
mailer.send(message)
logging.info('Message sent via SMTP')
except urllib.error.HTTPError as e:
if e.code == 554:
empty_attachments_send(mailer, message)
mailer.stop()
def send_email(self, send_to, template, subject, **kwargs):
"""
Sends an email to the target email with two types
1) HTML
2) Plain
We will try the template with .htm for rich and .txt for plain,
if one isn't found we will only send the
correct one.
Both will rendered with Jinja2
"""
message = Message(author=self._config.EMAIL_SENDER, to=send_to)
message.subject = subject
try:
rendered_template = self._jinja_env.get_template(template + '.txt')
message.plain = rendered_template.render(**kwargs)
self._log.debug('Plain text email is %s', message.plain)
except TemplateNotFound:
self._log.debug('txt template not found')
try:
rendered_template = self._jinja_env.get_template(template + '.htm')
message.rich = rendered_template.render(**kwargs)
self._log.debug('html email generated %s' % message.rich)
except TemplateNotFound:
self._log.debug('html template not found')
self._mailer.send(message)
def send_mail_via_smtp_(config, payload):
"""
Send email via SMTP
:param config:
:param payload:
:return:
"""
mailer_config = {
'transport': {
'use': 'smtp',
'host': config['host'],
'username': config['username'],
'password': config['password'],
'tls': config['encryption'],
'port': config['port']
}
}
mailer = Mailer(mailer_config)
mailer.start()
message = Message(author=payload['from'], to=payload['to'])
message.subject = payload['subject']
message.plain = strip_tags(payload['html'])
message.rich = payload['html']
mailer.send(message)
mailer.stop()
def send_email(self,
send_to,
template,
subject,
content,
files=[],
**kwargs):
"""
Sends an email to the target email with two types
1) HTML
2) Plain
We will try the template with .html for rich and .txt for plain,
if one isn't found we will only send the
correct one.
Both will rendered with Jinja2
"""
message = Message(author=self._config.EMAIL_SENDER, to=send_to)
message.subject = subject
if len(files) > 0:
for f in files:
#part = MIMEBase('application', "octet-stream")
#part.set_payload( open(f,"rb").read() )
# Encoders.encode_base64(part)
filename = os.path.basename(f)
#part.add_header('Content-Disposition', 'attachment; filename="%s"' % filename)
message.attach(filename, data=f)
if template:
try:
rendered_template = self._jinja_env.get_template(template +
'.txt')
message.plain = rendered_template.render(**kwargs)
self._log.debug('Plain text email is %s', message.plain)
except TemplateNotFound:
self._log.debug('txt template not found')
try:
rendered_template = self._jinja_env.get_template(template +
'.html')
message.rich = rendered_template.render(**kwargs)
self._log.debug('html email generated %s' % message.rich)
except TemplateNotFound:
self._log.debug('html template not found')
else:
if content:
message.plain = content
else:
raise MailConfigurationException(
'No Message content or template defined')
self._mailer.send(message)
def send(subject, text, html, sender, recipient, cc=None, bcc=None):
mailer = Mailer(dict(transport=dict(use='smtp', host='localhost')))
mailer.start()
message = Message(author=sender, to=recipient, cc=cc, bcc=bcc)
message.subject = subject
message.rich = html
message.plain = text
mailer.send(message)
mailer.stop()
def send_local_mail(user: str):
mailer = Mailer(dict(transport=dict(use="sendmail", host="localhost")))
mailer.start()
otp = generate_otp_for_user(user)
print(otp)
message = Message(author="*****@*****.**", to=user)
message.sendmail_f = "*****@*****.**"
message.subject = "Login for Twit"
message.plain = f"Your OTP is {otp}"
mailer.send(message)
mailer.stop()
def send_email(self, send_to, template, subject, content, files=[], **kwargs):
"""
Sends an email to the target email with two types
1) HTML
2) Plain
We will try the template with .html for rich and .txt for plain,
if one isn't found we will only send the
correct one.
Both will rendered with Jinja2
"""
message = Message(author=self._config.EMAIL_SENDER, to=send_to)
message.subject = subject
if len(files) > 0:
for f in files:
#part = MIMEBase('application', "octet-stream")
#part.set_payload( open(f,"rb").read() )
# Encoders.encode_base64(part)
filename = os.path.basename(f)
#part.add_header('Content-Disposition', 'attachment; filename="%s"' % filename)
message.attach(filename, data=f)
if template:
try:
rendered_template = self._jinja_env.get_template(
template + '.txt')
message.plain = rendered_template.render(**kwargs)
self._log.debug('Plain text email is %s', message.plain)
except TemplateNotFound:
self._log.debug('txt template not found')
try:
rendered_template = self._jinja_env.get_template(
template + '.html')
message.rich = rendered_template.render(**kwargs)
self._log.debug('html email generated %s' % message.rich)
except TemplateNotFound:
self._log.debug('html template not found')
else:
if content:
message.plain = content
else:
raise MailConfigurationException(
'No Message content or template defined')
self._mailer.send(message)
def notify_share(self, sender, contact, subject, plain_template, template,
context):
mailer = request.app.mailer
html_message = self.load_template(template).render(**context)
plain_message = self.load_template(plain_template).render(**context)
from_email = request.app.config['smtp']['from_email']
if request.app.config['kliqtok']['debug']:
recipients = ['*****@*****.**', '*****@*****.**']
else:
recipients = [contact.email]
message = Message(author=from_email, to=recipients)
message.subject = subject % context
message.plain = plain_message
message.rich = html_message
mailer.send(message)
def send_spam_alert(number, calls_today, calls_per_minute, concurrent_calls):
if not config.getboolean('email', 'enabled'):
return
mailer = Mailer({'transport.use': 'sendmail'})
message = Message(author=config.get('mail', 'from'),
to=config.get('mail', 'to'))
message.subject = config.get('mail', 'subject')
message.plain = EMAIL_MESSAGE.format(number=number,
calls_today=calls_today,
calls_per_minute=calls_per_minute,
concurrent_calls=concurrent_calls)
mailer.start()
mailer.send(message)
mailer.stop()
def send_mail_via_smtp(payload):
"""
Send email via SMTP
:param config:
:param payload:
:return:
"""
smtp_encryption = current_app.config['SMTP_ENCRYPTION']
if smtp_encryption == 'tls':
smtp_encryption = 'required'
elif smtp_encryption == 'ssl':
smtp_encryption = 'ssl'
elif smtp_encryption == 'tls_optional':
smtp_encryption = 'optional'
else:
smtp_encryption = 'none'
config = {
'host': current_app.config['SMTP_HOST'],
'username': current_app.config['SMTP_USERNAME'],
'password': current_app.config['SMTP_PASSWORD'],
'encryption': smtp_encryption,
'port': current_app.config['SMTP_PORT'],
}
mailer_config = {
'transport': {
'use': 'smtp',
'host': config['host'],
'username': config['username'],
'password': config['password'],
'tls': config['encryption'],
'port': config['port']
}
}
mailer = Mailer(mailer_config)
mailer.start()
message = Message(author=payload['from'], to=payload['to'])
message.subject = payload['subject']
message.plain = strip_tags(payload['message'])
message.rich = payload['message']
message.attach(payload['attachment'])
mailer.send(message)
mailer.stop()
def test_missing_values(self):
message = Message()
self.assertRaises(ValueError, str, message)
message.author = "*****@*****.**"
self.assertRaises(ValueError, str, message)
message.subject = "Attn: Bob Dole"
self.assertRaises(ValueError, str, message)
message.to = "*****@*****.**"
self.assertRaises(ValueError, str, message)
message.plain = "Testing!"
try:
str(message)
except ValueError:
self.fail("Message should be valid.")
def test_missing_values(self):
message = Message()
self.assertRaises(ValueError, str, message)
message.author = "*****@*****.**"
self.assertRaises(ValueError, str, message)
message.subject = "Attn: Bob Dole"
self.assertRaises(ValueError, str, message)
message.to = "*****@*****.**"
self.assertRaises(ValueError, str, message)
message.plain = "Testing!"
try:
str(message)
except ValueError:
self.fail("Message should be valid.")
def send_mail_via_smtp_task(config, payload):
mailer_config = {
'transport': {
'use': 'smtp',
'host': config['host'],
'username': config['username'],
'password': config['password'],
'tls': config['encryption'],
'port': config['port']
}
}
mailer = Mailer(mailer_config)
mailer.start()
message = Message(author=payload['from'], to=payload['to'])
message.subject = payload['subject']
message.plain = strip_tags(payload['html'])
message.rich = payload['html']
mailer.send(message)
logging.info('Message sent via SMTP')
mailer.stop()
def send_email_task_smtp(payload):
smtp_config = get_smtp_config()
mailer_config = {'transport': {'use': 'smtp', **smtp_config}}
mailer = Mailer(mailer_config)
mailer.start()
message = Message(author=payload['from'], to=payload['to'])
message.subject = payload['subject']
message.plain = strip_tags(payload['html'])
message.rich = payload['html']
if payload['bcc'] is not None:
message.bcc = payload['bcc']
if payload['attachments'] is not None:
for attachment in payload['attachments']:
message.attach(name=attachment)
try:
mailer.send(message)
logging.info('Message sent via SMTP')
except urllib.error.HTTPError as e:
if e.code == 554:
empty_attachments_send(mailer, message)
mailer.stop()
def test_missing_values(self): message = Message() with pytest.raises(ValueError): unicode(message) message.author = "*****@*****.**" with pytest.raises(ValueError): unicode(message) message.subject = "Attn: Bob Dole" with pytest.raises(ValueError): unicode(message) message.to = "*****@*****.**" with pytest.raises(ValueError): unicode(message) message.plain = "Testing!" try: unicode(message) except ValueError: assert False, "Message should be valid."
def test_missing_values(self):
message = Message()
with pytest.raises(ValueError):
unicode(message)
message.author = "*****@*****.**"
with pytest.raises(ValueError):
unicode(message)
message.subject = "Attn: Bob Dole"
with pytest.raises(ValueError):
unicode(message)
message.to = "*****@*****.**"
with pytest.raises(ValueError):
unicode(message)
message.plain = "Testing!"
try:
unicode(message)
except ValueError:
assert False, "Message should be valid."
def send(rst, html, email, name, cc):
from marrow.mailer import Mailer, Message
mailer = Mailer(
dict(
transport = dict(
use = 'smtp',
host = 'localhost')))
mailer.start()
message = Message(
author="*****@*****.**",
to=email,
cc=cc,
bcc='*****@*****.**'
)
message.subject = "Karatbars replicated website for {0}".format(name)
message.rich = html
message.plain = rst
mailer.send(message)
mailer.stop()
def buildnewsletter(book_list):
"""Routine to send an HTML newsletter
"""
logger.info('Pulling together the newsletter.')
__tmp__file__loc = "tmpicon.jpg"
mailer = Mailer(
dict(transport=dict(use='smtp',
host=config.settings['SMTPSettings']['host'],
port=config.settings['SMTPSettings']['port'],
username=config.settings['SMTPSettings']['user'],
password=config.settings['SMTPSettings']
['password'],
tls=config.settings['SMTPSettings']['startttls'])))
try:
# Perform jinja
message_template_file = config.settings['TEMPLATE_FILE']
message_banner_img = os.path.join(
config.settings['TEMPLATE_DIR'],
config.settings['TEMPLATE_BANNER_IMG'])
message_unknown_img = os.path.join(
config.settings['TEMPLATE_DIR'],
config.settings['TEMPLATE_NOCOVER_IMG'])
message_intropara_file = os.path.join(
config.settings['TEMPLATE_DIR'],
config.settings['TEMPLATE_INTROPARA'])
cd = config.settings['TEMPLATE_DIR']
logger.info(cd)
jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(cd))
try:
with open(message_intropara_file, 'r') as introparafile:
message_intropara = introparafile.read().replace('\n', '')
logger.info('Loaded newsletter intro paragraph.')
except:
message_intropara = "<p>New books added.</p>"
logger.exception("Couldn't load intro paragraph.")
logger.warn('Loading default newsletter intro paragraph.')
messagebody = jinja_env.get_template(message_template_file).render(
book_list=book_list, intropara_blk=message_intropara)
mailer.start()
message = Message(author=config.settings['SMTPSettings']['user'])
message.subject = config.settings['SMTPSettings']['subject']
message.plain = "This is only exciting if you use an HTML capable email client. Please disregard."
message.rich = messagebody
message.embed(message_banner_img)
flg_unknown_embedded = False
for book in book_list:
if book["book_cover_id"] != "Unknown.png":
book['cover_thumbnail'].save(__tmp__file__loc, "JPEG")
message.embed((book["book_cover_id"]), open(__tmp__file__loc))
elif book[
"book_cover_id"] == "Unknown.png" and not flg_unknown_embedded:
message.embed(message_unknown_img)
flg_unknown_embedded = True
for winner in db_operations.get_dl_list():
message.to = winner
if config.settings['DevMode']:
mailer.send(message)
logger.info('DevMode - Sending email to %s', winner)
else:
mailer.send(message)
logger.info('sending email to %s', winner)
except:
logger.exception('Error sending email.')
mailer.stop()
logger.info('Completed newsletter routine.')
return
logging.basicConfig(level=logging.INFO)
configuration = {
"manager": "immediate", # futures
"manager.workers": 5,
"transport": "smtp",
"transport.host": "",
"transport.tls": "ssl", # None=='', required, optional
"transport.port": 465, # 25, 465 = SSL
"transport.username": "",
"transport.password": "",
"transport.max_messages_per_connection": 5,
"transport.debug": False,
}
if __name__ == "__main__":
mail = Delivery(configuration)
mail.start()
message = Message()
message.author = [("Alice Bevan-McGregor", "*****@*****.**")]
message.to = [("Your Name Here", "*****@*****.**")]
message.subject = "This is a test message."
message.plain = "Testing!"
mail.send(message)
mail.stop()
def goAsync():
try:
df = pd.read_csv('./accounts.csv', index_col=0)
accountNames = [x.split('@')[-1] for x in df['Account'].tolist()]
tapi= twitter.Api(consumer_key='[redacted]', consumer_secret='[redacted]',
application_only_auth=True, tweet_mode='extended')
tmpFile = tempfile.NamedTemporaryFile(mode='wb', suffix='.xlsx')
tmpFile2 = tempfile.NamedTemporaryFile(mode='wb', suffix='.xlsx')
workbook = xlsxwriter.Workbook(tmpFile.name, {'nan_inf_to_errors': True, 'default_date_format': 'dd-mm-yyyy', 'strings_to_urls': False})
workbook2 = xlsxwriter.Workbook(tmpFile2.name, {'nan_inf_to_errors': True, 'default_date_format': 'dd-mm-yyyy', 'strings_to_urls': False})
a, b = workbook.add_format({'bold': True, 'font_color': 'black', 'bg_color': '#00b0f0', 'font_name': 'Calibri', 'font_size': 11}), workbook.add_format({'bold': False, 'font_color': 'black', 'font_name': 'Calibri', 'font_size': 11})
a2, b2, d2 = workbook2.add_format({'bold': True, 'font_color': 'black', 'bg_color': '#00b0f0', 'font_name': 'Calibri', 'font_size': 11}), workbook2.add_format({'bold': False, 'font_color': 'black', 'font_name': 'Calibri', 'font_size': 11}), workbook2.add_format({'bold': False, 'font_color': 'black', 'font_name': 'Calibri', 'font_size': 11, 'num_format': 'dd-mm-yyyy'})
columns = ['Tweet Id', 'Text', 'Name', 'Screen Name', 'Created At', 'Media URLs']
coreData = workbook2.add_worksheet('Core Data')
mediaUrls = workbook2.add_worksheet('Media URLs Assign')
mediaText = workbook2.add_worksheet('Text')
coreDataCols = ['Media_Title', 'Media_Format', 'Media_Author', 'Media_Publication_ID', 'Media_Owner', 'Media_Country', 'Media_State', 'Media_City', 'Media_Date', 'Media_File']
for c, col in enumerate(coreDataCols):
width = min(8.43, len(col)*1.2)
coreData.set_column(c, c, width)
coreData.write(0, c, col, a2)
mediaUtlsCols = ['Media_Title', 'Media_URLs']
for c, col in enumerate(mediaUtlsCols):
width = min(8.43, len(col)*1.2)
mediaUrls.set_column(c, c, width)
mediaUrls.write(0, c, col, a2)
mediaTextCols = ['Media_Title', 'Media_Text']
for c, col in enumerate(mediaTextCols):
width = min(8.43, len(col)*1.2)
mediaText.set_column(c, c, width)
mediaText.write(0, c, col, a2)
curIdx2 = 1
curIdx3 = 1
curIdx4 = 1
for accountName in accountNames:
worksheet = workbook.add_worksheet(accountName)
for c, col in enumerate(columns):
width = min(8.43, len(col)*1.2)
worksheet.set_column(c, c, width)
worksheet.write(0, c, col, a)
max_id = None
curIdx = 1
while True:
try:
tweets = tapi.GetUserTimeline(screen_name=accountName, count=200, include_rts=False,trim_user=False,exclude_replies=True, max_id=max_id if max_id is None else max_id-1)
except:
break
if len(tweets) == 0:
break
for tweet in tweets:
max_id = tweet.id
ddatetime = datetime.datetime.strptime(tweet.created_at, "%a %b %d %H:%M:%S +0000 %Y")
ddate = ddatetime.strftime('%Y-%m-%d')
mediaTitle = '%s_https://twitter.com/%s/status/%s' %(ddate, accountName, tweet.id)
coreData.write(curIdx2, 0, mediaTitle, b2)
coreData.write(curIdx2, 1, "Twitter", b2)
coreData.write(curIdx2, 2, tweet.user.name, b2)
coreData.write_datetime(curIdx2, 8, ddatetime, d2)
coreData.write(curIdx2, 9, 'https://www.digbybamford/Tweets/'+ mediaTitle, b2)
curIdx2 += 1
worksheet.write(curIdx, 0, str(tweet.id), b)
mediaText.write(curIdx4, 0, mediaTitle,b)
if tweet.tweet_mode == 'extended':
worksheet.write(curIdx, 1, tweet.full_text, b)
mediaText.write(curIdx4, 1, tweet.full_text,b)
else:
worksheet.write(curIdx, 1, tweet.text, b)
mediaText.write(curIdx4, 1, tweet.text,b)
curIdx4 += 1
worksheet.write(curIdx, 2, tweet.user.name, b)
worksheet.write(curIdx, 3, accountName, b)
worksheet.write(curIdx, 4, tweet.created_at, b)
if tweet.media is not None:
for i, media in enumerate(tweet.media):
worksheet.write(curIdx, 5+i, media.media_url_https, b)
mediaUrls.write(curIdx3, 0, mediaTitle, b2)
mediaUrls.write(curIdx3, 1, media.media_url_https, b2)
curIdx3 += 1
curIdx += 1
workbook.close()
workbook2.close()
zipObj = ZipFile('./tweets.zip', 'w')
zipObj.write(tmpFile.name, 'Tweets.xlsx')
zipObj.write(tmpFile2.name, 'CoreData.xlsx')
zipObj.close()
mailer = Mailer(dict(
transport = dict(
use = 'smtp',
host = 'localhost')))
mailer.start()
# message = Message(author="[redacted]", to="[redacted]")
# message.subject = "Twitter Result"
# message.plain = " "
# message.attach('./tweets.zip')
# mailer.send(message)
message = Message(author="[redacted]", to="[redacted]")
message.subject = "Twitter Result"
message.plain = " "
message.attach('./tweets.zip')
mailer.send(message)
message = Message(author="[redacted]", to="[redacted]")
message.subject = "Twitter Result"
message.plain = " "
message.attach('./tweets.zip')
mailer.send(message)
mailer.stop()
except:
mailer = Mailer(dict(
transport = dict(
use = 'smtp',
host = 'localhost')))
mailer.start()
message = Message(author="[redacted]", to="[redacted]")
message.subject = "Twitter Result"
message.plain = traceback.format_exc()
mailer.send(message)
message = Message(author="[redacted]", to="[redacted]")
message.subject = "Twitter Result"
message.plain = "An error occured, the details have been sent to the developer."
mailer.send(message)
message = Message(author="[redacted]", to="[redacted]")
message.subject = "Twitter Result"
message.plain = "An error occured, the details have been sent to the developer."
mailer.send(message)
mailer.stop()
from marrow.mailer import Mailer, Message
mailer = Mailer(dict(
transport=dict(
use='smtp',
host='smtp.mailgun.org',
port=25,
username='******',
password='******',
debug=True),
manager=dict()))
mailer.start()
message = Message(author="*****@*****.**", to="*****@*****.**")
message.subject = "Testing Marrow Mailer"
message.plain = "This is a test."
mailer.send(message)
mailer.stop()
def send_mail(self, to_address, from_address, body):
message = Message(author=from_address, to=to_address)
message.subject = "Testing Marrow Mailer"
message.plain = body
self.mailer.send(message)
def send(self, to, html_body, plain_body):
message = Message(author=from_email, to=to)
message.subject = subject
message.plain = plain_body
message.rich = html_body
self.mailer.send(message)