def send_to_admin(serversmtp, frm, to, error, cur):
logger.info('Send email about error to admin')
# Get admin email address from database
cur.execute("SELECT mb_value FROM `mb_properties` WHERE mb_field='Admin email'")
admin = cur.fetchone()[0]
# Create email fo admin
msg = Message()
msg.add_header('Subject', 'SRK DPIportal [Mail Sender] Impossible send email!')
msg.add_header('Date', formatdate(localtime=True))
msg.add_header('X-Mailer', 'MailSender')
msg.add_header('Message-ID', make_msgid())
msg.add_header('From', frm)
msg.add_header('To', admin)
msg.set_payload('Subject:' + msg['Subject'] + '\n'
'From:' + frm + '\n'
'To:' + admin + '\n\n'
'Impossible send email to ' + to + '\n'
'Error:\n' + error)
try:
serversmtp.sendmail(msg['From'],
msg['To'].split('; '),
msg.get_payload())
logger.info('Mail was send to %s' % admin)
except Exception as e:
logger.error(str(e))
logger.info('Impossible send email to admin %s' % admin)
def send_auth_email(auth_token, destination, username, password):
msg = Message()
msg.add_header("subject", "Cathedral Admin Access")
msg.set_payload(AUTH_EMAIL.format(auth_token=auth_token))
server = smtplib.SMTP("smtp.gmail.com:587")
server.starttls()
server.login(username, password)
server.sendmail(username, destination, msg.as_string())
server.quit()
def _prepare_payload(self):
"""Serializes a batch request body."""
for qry in self.context.get_next_query():
request = self.context.build_request()
if isinstance(qry, ReadEntityQuery):
self._get_requests.append(request)
self._get_queries.append(qry)
else:
self._change_requests.append(request)
main_message = Message()
main_message.add_header("Content-Type", "multipart/mixed")
main_message.set_boundary(self._current_boundary)
if len(self._change_requests) > 0:
change_set_message = Message()
change_set_boundary = _create_boundary("changeset_", True)
change_set_message.add_header("Content-Type", "multipart/mixed")
change_set_message.set_boundary(change_set_boundary)
for request in self._change_requests:
part_message = self._serialize_request(request)
change_set_message.attach(part_message)
main_message.attach(change_set_message)
for request in self._get_requests:
part_message = self._serialize_request(request)
main_message.attach(part_message)
return main_message
def control_to_metadata(control_dir, wheel_dir):
"""Convert deb control to METADATA file."""
ctrl_info = read_control(control_dir)
pkg_name = ctrl_info['Package'].replace('-', '_')
pkg_version = re.search(r'\d.*', ctrl_info['Version'].replace('-', '_'))
pkg_string = "%s-%s" % (pkg_name, pkg_version)
metadata = Message()
metadata.add_header('Metadata-Version', '2.0')
metadata['Name'] = ctrl_info['Package']
metadata['Version'] = pkg_version
metadata['Home-page'] = ctrl_info['Homepage']
# get maintainer name and email
maintainer_pattern = r'\s*(?P<maintainer>.*?)\s*?\<(?P<m_email>.*?)\>'
re_results = re.search(maintainer_pattern, ctrl_info['Maintainer'])
metadata['Author'] = re_results.group('maintainer')
metadata['Author-email'] = re_results.group('m_email')
metadata['Summary'] = ctrl_info['Description'].split('\n', 1)[0]
metadata['Description'] = ctrl_info['Description']
# Write wheelfile
dist_info_dir = wheel_dir + "/" + pkg_string + ".dist-info"
os.mkdir(dist_info_dir)
metadata_path = os.path.join(dist_info_dir, 'METADATA')
write_pkg_info(metadata_path, metadata)
return (pkg_name, pkg_version)
def limit_reached_alert(user, limit_type, limit, value):
"""
Send out a notification when a limit is reached.
:param user: The user who has hit the limit
:type user: User
:param limit_type: The type of limit that has been reached
:type limit_type: str
:param limit: The limit amount
:type limit: int
:param value: The number of messages sent
:type value: int
"""
name = get_config('alerts_name')
faddr = get_config('alerts_from')
taddr = get_config('alerts_to')
message = MIMEMessage()
message.add_header('From', '"%s" <%s>' % (name, faddr))
if isinstance(taddr, list):
message.add_header('To', ', '.join(taddr))
else:
message.add_header('To', taddr)
message.add_header('Date', formatdate())
message.add_header('Subject', 'User %s reached sending limit' % user.email)
message.set_payload("""Hi,
The user has reached their %s limit of sending messages. They have sent %d
messages and have a limit of %d""" % (limit_type, value, limit))
# Send the message to the local SMTP server
smtp = smtplib.SMTP('localhost')
smtp.sendmail(faddr, taddr, str(message))
smtp.close()
def urlgetcontent(self, container, url, data = None, method = None, headers = {}, tostr = False, encoding = None, rawurl = False, *args, **kwargs):
'''
In Python2, bytes = str, so tostr and encoding has no effect.
In Python3, bytes are decoded into unicode str with encoding.
If encoding is not specified, charset in content-type is used if present, or default to utf-8 if not.
See open for available arguments
:param rawurl: if True, assume the url is already url-encoded, do not encode it again.
'''
req = Request(url, data, method, headers, rawurl = rawurl)
for m in self.open(container, req, *args, **kwargs):
yield m
resp = container.retvalue
encoding = 'utf-8'
if encoding is None:
m = Message()
m.add_header('Content-Type', resp.get_header('Content-Type', 'text/html'))
encoding = m.get_content_charset('utf-8')
if not resp.stream:
content = b''
else:
for m in resp.stream.read(container):
yield m
content = container.data
if tostr:
content = _str(content, encoding)
container.retvalue = content
def _get_email_mesg(self, header, body):
""" Return an email message.
Create an email message object from the provided header and body
and return the email message object.
Params
======
header: Dictionary contain email message header contents.
body: Either a string or a file containing the body of the message.
Return
======
A valid email message object ready to send via SMTP.
"""
from email.message import Message
mesg = Message()
for h,v in header.items():
mesg.add_header(h, v)
try:
mesg.set_payload(body.read())
except AttributeError:
mesg.set_payload(body)
return mesg
def __thread_send_email(email_subject, email_from, email_from_password,
email_to, email_content, email_smtp_host,
email_smtp_port):
msg = Message()
msg['Subject'] = email_subject
msg['From'] = email_from
msg['To'] = email_to
msg.add_header('Content-Type', 'text/html')
msg.set_payload(email_content)
logging.info('send_email() - sending an e-mail to `%s`...', email_to)
try:
s = SMTP(host=email_smtp_host, port=email_smtp_port)
s.starttls()
s.login(msg['From'], email_from_password)
s.sendmail(msg['From'], [msg['To']], msg.as_string())
s.quit()
logging.info(
'send_email() - e-mail to `%s` has been sent successfully!',
email_to)
except SMTPException as error:
logging.error('send_email() - unable to send an e-mail to `%s`.',
email_to)
logging.error('send_email() - error: `%s`.', error)
raise error
def _serialize_request(request):
"""Serializes a part of a batch request to a string. A part can be either a GET request or
a change set grouping several CUD (create, update, delete) requests.
:type request: RequestOptions
"""
eol = "\r\n"
method = request.method
if "X-HTTP-Method" in request.headers:
method = request.headers["X-HTTP-Method"]
lines = [
"{method} {url} HTTP/1.1".format(method=method, url=request.url),
*[':'.join(h) for h in request.headers.items()]
]
if request.data:
lines.append(eol)
lines.append(json.dumps(request.data))
buffer = eol + eol.join(lines) + eol
payload = buffer.encode('utf-8').lstrip()
message = Message()
message.add_header("Content-Type", "application/http")
message.add_header("Content-Transfer-Encoding", "binary")
message.set_payload(payload)
return message
def enviar_email(data, paciente, medico, contato, sistema_operacional,
data_resp):
hoje = date.today()
server = smtplib.SMTP('smtp.gmail.com:587')
email_content = f'''
<p>Prezado(a){paciente},</p>
</p>Segue o resultado da analise do seu exame realizado pela nossa inteligencia artificial no dia: {hoje}</p>
{data_resp.to_html()}
</p> De acordo com a inteligencia utilizada, seu diagnostico foi {data} para diabetes.</p>
</p>A nossa equipe sugere que o(a) paciente, procure o(a) Dr.(a) {medico}.</p>
<p>Grato,Equipe Vinicius Mattoso</p>'''
msg = Message()
msg['Subject'] = f'Resultado do exame avaliado no dia: {hoje}'
msg['From'] = sistema_operacional.email
msg['To'] = contato
password = sistema_operacional.key
msg.add_header('Content-Type', 'text/html')
msg.set_payload(email_content)
s = smtplib.SMTP('smtp.gmail.com: 587')
s.starttls()
# Login Credentials for sending the mail
s.login(msg['From'], password)
s.sendmail(msg['From'], [msg['To']], msg.as_string().encode('utf-8'))
def urlgetcontent(self,
container,
url,
data=None,
method=None,
headers={},
tostr=False,
encoding=None,
*args,
**kwargs):
'''
In Python2, bytes = str, so tostr and encoding has no effect.
In Python3, bytes are decoded into unicode str with encoding.
If encoding is not specified, charset in content-type is used if present, or default to utf-8 if not.
See open for available arguments
'''
req = Request(url, data, method, headers)
for m in self.open(container, req, *args, **kwargs):
yield m
resp = container.retvalue
encoding = 'utf-8'
if encoding is None:
m = Message()
m.add_header('Content-Type',
resp.get_header('Content-Type', 'text/html'))
encoding = m.get_content_charset('utf-8')
if not resp.stream:
content = b''
else:
for m in resp.stream.read(container):
yield m
content = container.data
if tostr:
content = _str(content, encoding)
container.retvalue = content
def https_open(self, request):
global disable_network
if disable_network:
raise URLError('Network access is disabled')
url = request.get_full_url()
data = GetRequestData(request)
digest = DigestFromRequest(request)
response_file_path = os.path.join(RESPONSE_DATA_DIR, digest)
requests_seen.append(request)
if os.path.exists(response_file_path):
f = open(response_file_path, mode='rb')
m = Message()
m.add_header('Content-Type', 'application/json')
resp = addinfourl(f, headers=m, url=url, code=200)
resp.msg = 'Success'
resp.code = 200
return resp
# The file was not there. Create a missing resource file.
missing_response_file_path = os.path.join(RESPONSE_DATA_DIR,
'{}.missing'.format(digest))
with open(missing_response_file_path, mode='wb') as f:
s = json.dumps({
"url": url,
"data": StringFromBytes(data),
"digest": digest
})
f.write(s.encode('utf-8'))
raise URLError(
'URL is not cached. Created missing request record: {}.missing'.
format(digest))
async def urlgetcontent(self,
container,
url,
data=None,
method=None,
headers={},
tostr=False,
encoding=None,
rawurl=False,
*args,
**kwargs):
'''
In Python2, bytes = str, so tostr and encoding has no effect.
In Python3, bytes are decoded into unicode str with encoding.
If encoding is not specified, charset in content-type is used if present, or default to utf-8 if not.
See open for available arguments
:param rawurl: if True, assume the url is already url-encoded, do not encode it again.
'''
req = Request(url, data, method, headers, rawurl=rawurl)
with (await self.open(container, req, *args, **kwargs)) as resp:
encoding = 'utf-8'
if encoding is None:
m = Message()
m.add_header('Content-Type',
resp.get_header('Content-Type', 'text/html'))
encoding = m.get_content_charset('utf-8')
if not resp.stream:
content = b''
else:
content = await resp.stream.read(container)
if tostr:
content = _str(content, encoding)
return content
def _construct_multipart_request(self, request):
"""
:type request: office365.runtime.http.request_options.RequestOptions
"""
request.method = HttpMethod.Post
boundary = create_boundary("PageBoundary", True)
request.set_header(
"Content-Type",
"multipart/form-data; boundary={0}".format(boundary))
main_message = Message()
main_message.add_header(
"Content-Type",
"multipart/form-data; boundary={0}".format(boundary))
main_message.set_boundary(boundary)
c_type, enc = get_mime_type(self._presentation.name)
presentation_message = Message()
presentation_message.add_header("Content-Type", c_type)
presentation_message.add_header("Content-Disposition",
"form-data; name=\"Presentation\"")
presentation_message.set_payload(self._presentation.read())
main_message.attach(presentation_message)
for name, file in self._files.items():
file_message = Message()
c_type, enc = get_mime_type(file.name)
file_message.add_header("Content-Type", c_type)
file_message.add_header("Content-Disposition",
"form-data; name=\"{0}\"".format(name))
file_content = file.read()
file_message.set_payload(file_content)
main_message.attach(file_message)
request.data = _message_to_payload(main_message)
def _prepare_payload(self):
"""
Serializes a batch request body.
"""
main_message = Message()
main_message.add_header("Content-Type", "multipart/mixed")
main_message.set_boundary(self.current_query.current_boundary)
if self.current_query.has_change_sets:
change_set_message = Message()
change_set_boundary = create_boundary("changeset_", True)
change_set_message.add_header("Content-Type", "multipart/mixed")
change_set_message.set_boundary(change_set_boundary)
for qry in self.current_query.change_sets:
request = qry.build_request()
message = self._serialize_request(request)
change_set_message.attach(message)
main_message.attach(change_set_message)
for qry in self.current_query.get_queries:
request = qry.build_request()
message = self._serialize_request(request)
main_message.attach(message)
return message_as_bytes_or_string(main_message)
def test_encode_subject(self):
email = Message()
email.add_header('Subject', 'Vielen Dank für Ihren Fahrkartenkauf! (Auftrag TSYLM7)')
email.add_header('From', '_value')
email['categorized'] = {}
out_mail = EmailCleanup('_from', 'to', '%(outro)s').prepare_outbound(email)
self.assertEqual(str(out_mail['Subject']),
'=?iso-8859-1?q?=28was=3A_Vielen_Dank_f=FCr_Ihren_Fahrkartenkauf!_=28Auftr?=\n =?iso-8859-1?q?ag_TSYLM7=29=29?=')
def create_message(sender_email: str, receiver_email: str, subject: str, html_body):
message = Message()
message["Subject"] = subject
message["From"] = sender_email
message["To"] = receiver_email
message.add_header('Content-Type', 'text/html')
message.set_payload(html_body)
return message
def addmimeblob(self, blob, mimetype, filename):
attach = Message()
attach['Content-Type'] = mimetype
attach.add_header('Content-Disposition', 'inline', filename=filename)
attach.set_payload(blob)
encode_base64(attach)
self._endtext()
self._attached.append(attach)
def write_headers(socket, headers):
if headers:
msg = Message()
for key, values in normalized_headers(headers.items()).iteritems():
for value in values:
msg.add_header(key, value)
header_data = msg.as_string()
yield socket.sendall(header_data.rstrip("\n").replace("\n", "\r\n") + "\r\n")
yield socket.sendall("\r\n")
def send_mail(self, recipient, payload, subject=None):
msg = Message()
msg['Subject'] = subject
msg['From'] = Environment().mail_username
msg['To'] = recipient
msg.add_header('Content-Type', 'text/html')
msg.set_payload(payload)
self.server.sendmail(Environment().mail_username, recipient,
msg.as_string())
def test_unit__decoded_mail__check_validity_for_comment_content__err__is_autoreply_email(
self, header_name, header_value
):
message = Message()
message.add_header(header_name, header_value)
uid = 1
decodedmail = DecodedMail(message, uid)
with pytest.raises(AutoReplyEmailNotAllowed):
decodedmail.check_validity_for_comment_content()
def _find_content_encoding(response, default='iso8859-1'):
from email.message import Message
content_type = response.headers.get('Content-Type')
if content_type:
msg = Message()
msg.add_header('Content-Type', content_type)
charset = msg.get_content_charset(default)
else:
charset = default
return charset
def _find_content_encoding(response, default='iso8859-1'):
from email.message import Message
content_type = response.headers.get('Content-Type')
if content_type:
msg = Message()
msg.add_header('Content-Type', content_type)
charset = msg.get_content_charset(default)
else:
charset = default
return charset
def message_from_record(self, record):
from email.message import Message
msg = Message()
lineiter = iter(self.format(record).splitlines())
for line in lineiter:
if not line:
break
pieces = line.split(':', 1)
msg.add_header(*[x.strip() for x in pieces])
msg.set_payload('\r\n'.join(lineiter))
return msg
def send_mail(from_addr, to_addr, subject, body):
msg = Message()
msg['Subject'] = subject
msg['From'] = from_addr
msg['To'] = to_addr if isinstance(to_addr, str) else ', '.join(to_addr)
msg.add_header('Content-Type', 'text/html')
msg.set_payload(body)
smtp = SMTP('localhost')
smtp.sendmail(from_addr, to_addr, msg.as_string())
smtp.quit()
def prepare_message(
sender_: EmailAddress,
recipient_: EmailAddress,
subject: typing.Text,
text: typing.Text,
) -> MIMEBase:
sender = Address(sender_.name, addr_spec=sender_.address)
recipient = Address(recipient_.name, addr_spec=recipient_.address)
html = markdown.markdown(text)
plaintext_message = EmailMessage()
plaintext_message["Subject"] = subject
plaintext_message["From"] = sender
plaintext_message["To"] = (recipient, )
plaintext_message.set_content(text)
plaintext_message.add_alternative(html, subtype="html")
encrypted_text = encrypt_text(recipient.addr_spec,
plaintext_message.as_string())
encrypted_message = MIMEBase(_maintype="multipart",
_subtype="encrypted",
protocol="application/pgp-encrypted")
encrypted_message["Subject"] = subject
encrypted_message["From"] = str(sender)
encrypted_message["To"] = str(recipient)
encrypted_message_part1 = Message()
encrypted_message_part1.add_header(_name="Content-Type",
_value="application/pgp-encrypted")
encrypted_message_part1.add_header(
_name="Content-Description", _value="PGP/MIME version identification")
encrypted_message_part1.set_payload("Version: 1" + "\n")
encrypted_message_part2 = Message()
encrypted_message_part2.add_header(_name="Content-Type",
_value="application/octet-stream",
name="encrypted.asc")
encrypted_message_part2.add_header(_name="Content-Description",
_value="OpenPGP encrypted message")
encrypted_message_part2.add_header(_name="Content-Disposition",
_value="inline",
filename="encrypted.asc")
encrypted_message_part2.set_payload(encrypted_text)
encrypted_message.attach(encrypted_message_part1)
encrypted_message.attach(encrypted_message_part2)
return encrypted_message
def sendMail():
# Initializing SMTP
s = smtplib.SMTP('smtp.gmail.com', 587)
# start TLS for security
s.starttls()
# Mail ID and credential from where all the mails will be sent are to be given here
# USE CHRIST ID!!! Personal mails have restrictions on the number of mails that can be sent
s.login("Your Mail ID Ex- [email protected]",
"Your Password")
# The content variable will hold the JSON request body
content = request.get_json()
# Access the otp field that is within the JSON request
otp = content['otp']
# Access the email field that is within the JSON request
email = content['email']
# Email content definition
email_cont = """
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Open Elective OTP</title>
</head>
<body>
<h1>Your Open Elective authentication OTP is <strong>""" + otp + """</strong></h1>
</body>
</html>
"""
# Construction of the message to be sent
msg = Message()
msg['Subject'] = "Open Elective OTP"
msg['From'] = 'CHRIST (Deemed to be University)'
msg['To'] = 'You'
msg.add_header('Content-Type', 'text/html')
msg.set_payload(email_cont)
# Sending the Mail
# The mail ID specified above to be given here again
s.sendmail("Your Mail ID Ex- [email protected]",
email, msg.as_string())
# Close SMTP session
s.quit()
# Sends a success response
resp = jsonify(success=True)
return resp
def create_msg(v,rcptlist=None,origmsg=None,template=None):
"""Create a DSN message from a template. Template must be '\n' separated.
v - an object whose attributes are used for substitutions. Must
have sender and receiver attributes at a minimum.
rcptlist - used to set v.rcpt if given
origmsg - used to set v.subject and v.spf_result if given
template - a '\n' separated string with python '%(name)s' substitutions.
"""
if not template:
return None
if hasattr(v,'perm_error'):
# likely to be an spf.query, try translating for backward compatibility
q = v
v = Vars()
try:
v.heloname = q.h
v.sender = q.s
v.connectip = q.i
v.receiver = q.r
v.sender_domain = q.o
v.result = q.result
v.perm_error = q.perm_error
except: v = q
if rcptlist:
v.rcpt = '\n\t'.join(rcptlist)
if origmsg:
try: v.subject = origmsg['Subject']
except: v.subject = '(none)'
try:
v.spf_result = origmsg['Received-SPF']
except: v.spf_result = None
msg = Message()
msg.add_header('X-Mailer','PyMilter-'+Milter.__version__)
msg.set_type('text/plain')
hdrs,body = template.split('\n\n',1)
for ln in hdrs.splitlines():
name,val = ln.split(':',1)
msg.add_header(name,(val % v.__dict__).strip())
msg.set_payload(body % v.__dict__)
# add headers if missing from old template
if 'to' not in msg:
msg.add_header('To',v.sender)
if 'from' not in msg:
msg.add_header('From','postmaster@%s'%v.receiver)
if 'auto-submitted' not in msg:
msg.add_header('Auto-Submitted','auto-generated')
return msg
def test_attachment_name_badly_encoded(self):
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<dummy>"
msg.set_payload(b"Dummy content")
msg.add_header(b'Content-Disposition', b'attachment', filename=b'non-ascii-\xb8\xb1\xb1\xbe.jpg')
scrubber = Scrubber("*****@*****.**", msg)
try:
attachments = scrubber.scrub()[1]
except UnicodeDecodeError:
print(format_exc())
self.fail("Could not decode the filename")
self.assertEqual(attachments,
[(0, u'attachment.bin', 'text/plain', None, b'Dummy content')])
def send_sms(data):
text, coding, parts_count = detect_coding(data['text'])
result = {
'sent_text': data['text'],
'parts_count': parts_count,
'mobiles': {}
}
for mobile in data['mobiles']:
# generate message_id
message_id = str(uuid.uuid4())
result['mobiles'][mobile] = {}
result['mobiles'][mobile]['message_id'] = message_id
result['mobiles'][mobile]['dlr_status'] = os.path.join(
os.path.dirname(request.url),
os.path.basename(current_app.config['SENT']), message_id)
if not validate_mobile(mobile):
current_app.logger.info(
'Message from [%s] to [%s] have invalid mobile number' %
(auth.username(), mobile))
result['mobiles'][mobile][
'response'] = 'Failed: invalid mobile number'
continue
if access_mobile(mobile):
lock_file = os.path.join(current_app.config['OUTGOING'],
message_id + '.LOCK')
m = Message()
m.add_header('From', auth.username())
m.add_header('To', mobile)
m.add_header('Alphabet', coding)
if data.get('queue'):
result.update({'queue': data['queue']})
m.add_header('Queue', result.get('queue'))
m.set_payload(text)
with open(lock_file, write_mode) as fp:
if use_python3:
fp.write(m.as_bytes())
else:
fp.write(m.as_string())
msg_file = lock_file.split('.LOCK')[0]
os.rename(lock_file, msg_file)
os.chmod(msg_file, 0o660)
current_app.logger.info(
'Message from [%s] to [%s] placed to the spooler as [%s]' %
(auth.username(), mobile, msg_file))
result['mobiles'][mobile]['response'] = 'Ok'
else:
current_app.logger.info(
'Message from [%s] to [%s] have forbidden mobile number' %
(auth.username(), mobile))
result['mobiles'][mobile][
'response'] = 'Failed: forbidden mobile number'
return result
def gut_message(message: Message) -> Message:
"""
Remove body from a message, and wrap in a message/external-body.
"""
wrapper = Message()
wrapper.add_header('Content-Type',
'message/external-body',
access_type='x-spam-deleted',
expiration=time.strftime("%a, %d %b %Y %H:%M:%S %z"),
size=str(len(message.get_payload())))
message.set_payload('')
wrapper.set_payload([message])
return wrapper
def test_attachment_name_badly_encoded(self):
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<dummy>"
msg.set_payload(b"Dummy content")
msg.add_header(b'Content-Disposition', b'attachment',
filename=b'non-ascii-\xb8\xb1\xb1\xbe.jpg')
scrubber = Scrubber(msg)
try:
attachments = scrubber.scrub()[1]
except UnicodeDecodeError:
print(format_exc())
self.fail("Could not decode the filename")
self.assertEqual(
attachments,
[(0, u'attachment.bin', 'text/plain', None, b'Dummy content')])
def add_payload(message, obj):
payload = Message()
encoding = obj.get("encoding", "utf-8")
if encoding and (encoding.upper() in ("BASE64", "7BIT", "8BIT", "BINARY")):
payload.add_header("Content-Transfer-Encoding", encoding)
else:
payload.set_charset(encoding)
mime = obj.get("mime", None)
if mime:
payload.set_type(mime)
if "text" in obj:
payload.set_payload(obj["text"])
elif "payload" in obj:
payload.set_payload(obj["payload"])
if "filename" in obj and obj["filename"]:
payload.add_header("Content-Disposition", "attachment", filename=obj["filename"])
message.attach(payload)
def ftp_listdir(url):
assert url.lower().startswith('ftp://')
from email.message import Message
res = urlopen(url)
content_type = res.headers.get('Content-Type')
if content_type:
msg = Message()
msg.add_header('Content-Type', content_type)
charset = msg.get_content_charset('utf-8')
else:
charset = 'utf-8'
if content_type and content_type.startswith('text/html'):
files = parse_html_ftplist(res.read().decode(charset))
else:
files = parse_text_ftplist(res.read().decode(charset))
res.close()
return files
def emsg(kv):
from email.message import Message
from email.generator import Generator
from StringIO import StringIO
m = Message()
m['Content-type'] = 'multipart/formdata'
for k,v in kv.items():
p = Message()
p.add_header('Content-Disposition', 'form-data', name=k)
p.set_payload(v)
m.attach(p)
#print m.as_string()
fp = StringIO()
g = Generator(fp)
g.flatten(m)
return fp.getvalue()
def ftp_listdir(url):
assert url.lower().startswith('ftp://')
from email.message import Message
res = urlopen(url)
content_type = res.headers.get('Content-Type')
if content_type:
msg = Message()
msg.add_header('Content-Type', content_type)
charset = msg.get_content_charset('utf-8')
else:
charset = 'utf-8'
if content_type and content_type.startswith('text/html'):
files = parse_html_ftplist(res.read().decode(charset))
else:
files = parse_text_ftplist(res.read().decode(charset))
res.close()
return files
def build_message(self, subject=None, body=None):
email = Message()
email.add_header("From", self.myself)
email.add_header("To", self.myself)
email.add_header("Date", formatdate(None, self.use_local_timezone))
if subject is not None:
email.add_header("Subject", subject)
if body is not None:
email.set_payload(body)
return email
def _prepare_message(txt):
""" Apply the proper encoding to all email fields.
The body will be Latin-1, the headers will be 'quopri'd when necessary.
"""
def plain(val):
""" Return True when val is plain ASCII """
try:
val.decode('ascii')
return True
except:
return False
# Use Latin-1 because not all email clients know UTF-8.
code = 'ISO-8859-1'
msg = Message()
payload = []
body = False
header = False
for line in txt.encode(code, 'replace').split('\n'):
if header and not line:
body = True
if body:
payload.append(line)
else:
m = RE_HEADER.search(line)
if m:
header = True
keyword = m.group(1).strip()
value = m.group(2).strip()
if plain(value):
# Don't encode if not needed, because some email clients
# choke when headers like "date" are encoded.
msg.add_header(keyword, value)
else:
header = Header(value, code)
msg[keyword] = header
msg.set_payload('\n'.join(payload), code)
# Check for proper encoding, else call it explicitly
if not msg.has_key('Content-Transfer-Encoding'):
encode_quopri(msg)
return msg.as_string()
def _prepare_message(txt):
""" Apply the proper encoding to all email fields.
The body will be Latin-1, the headers will be 'quopri'd when necessary.
"""
def plain(val):
""" Return True when val is plain ASCII """
try:
val.decode('ascii')
return True
except:
return False
# Use Latin-1 because not all email clients know UTF-8.
code = 'ISO-8859-1'
msg = Message()
payload = []
body = False
header = False
for line in txt.encode(code, 'replace').split('\n'):
if header and not line:
body = True
if body:
payload.append(line)
else:
m = RE_HEADER.search(line)
if m:
header = True
keyword = m.group(1).strip()
value = m.group(2).strip()
if plain(value):
# Don't encode if not needed, because some email clients
# choke when headers like "date" are encoded.
msg.add_header(keyword, value)
else:
header = Header(value, code)
msg[keyword] = header
msg.set_payload('\n'.join(payload), code)
# Check for proper encoding, else call it explicitly
if not msg.has_key('Content-Transfer-Encoding'):
encode_quopri(msg)
return msg.as_string()
def multipart_form_message(images, form_data={}):
"""Return a MIMEMultipart message to upload images via an HTTP form POST request.
Args:
images: a list of (encoded_image, filename) tuples.
form_data: dict of name, value form fields.
"""
message = MIMEMultipart('form-data', None)
for name, val in form_data.iteritems():
part = Message()
part.add_header('Content-Disposition', 'form-data', name=name)
part.set_payload(val)
message.attach(part)
for im, filename in images:
message.attach(form_data_image(im, filename))
return message
def addMail(self, body="", filename="foo", to=ADDRESS,
frm="*****@*****.**", subject="sent subject",
headers={}):
msg = Message()
msg.add_header("To", to)
msg.add_header(
"Delivered-To", UUID + "@deliver.local")
msg.add_header("From", frm)
msg.add_header("Subject", subject)
for header, value in headers.iteritems():
msg.add_header(header, value)
msg.set_payload(body)
path = os.path.join(self.directory, "new", filename)
with open(path, "w") as f:
f.write(msg.as_string())
return msg.as_string(), path
def test_sendmail_with_email_header(self):
"""Check the timeline is ok even if there is an email.header.Header.
See https://bugs.launchpad.net/launchpad/+bug/885972
"""
fake_mailer = RecordingMailer()
self.useFixture(ZopeUtilityFixture(fake_mailer, IMailDelivery, 'Mail'))
subject_str = self.getUniqueString('subject')
subject_header = email.header.Header(subject_str)
message = Message()
message.add_header('From', '*****@*****.**')
message['Subject'] = subject_header
message.add_header('To', '*****@*****.**')
with CaptureTimeline() as ctl:
sendmail.sendmail(message)
self.assertEqual(fake_mailer.from_addr, '*****@*****.**')
self.assertEqual(fake_mailer.to_addr, ['*****@*****.**'])
self.checkTimelineHasOneMailAction(ctl.timeline, subject=subject_str)
def message_from_record(self, record, suppressed):
"""Creates a new message for a record as email message object
(:class:`email.message.Message`). `suppressed` is the number
of mails not sent if the `record_limit` feature is active.
"""
from email.message import Message
msg = Message()
lineiter = iter(self.format(record).splitlines())
for line in lineiter:
if not line:
break
pieces = line.split(':', 1)
msg.add_header(*[x.strip() for x in pieces])
body = '\r\n'.join(lineiter)
if suppressed:
body += '\r\n\r\nThis message occurred additional %d ' \
'time(s) and was suppressed' % suppressed
msg.set_payload(body)
return msg
def add_payload(message, obj):
payload = Message()
encoding = obj.get("encoding", "utf-8")
if encoding and (encoding.upper() in ("BASE64", "7BIT", "8BIT", "BINARY")):
payload.add_header("Content-Transfer-Encoding", encoding)
else:
payload.set_charset(encoding)
mime = obj.get("mime", None)
if mime:
payload.set_type(mime)
if "text" in obj:
payload.set_payload(obj["text"])
elif "payload" in obj:
payload.set_payload(obj["payload"])
if "filename" in obj and obj["filename"]:
payload.add_header(
"Content-Disposition", "attachment", filename=obj["filename"]
)
message.attach(payload)
def multipart_form_message(media, form_data={}):
"""Return a MIMEMultipart message to upload encoded media via an HTTP form POST request.
Args:
media: a list of (encoded_data, filename) tuples.
form_data: dict of name, value form fields.
"""
message = MIMEMultipart("form-data", None)
if form_data:
for name, val in form_data.iteritems():
part = Message()
part.add_header("Content-Disposition", "form-data", name=name)
part.set_payload(val)
message.attach(part)
for im, filename in media:
message.attach(form_data_media(im, filename))
return message
def read(self, length=None):
offset = self._offset
byte_range = 'bytes=%d-' % offset
if length is not None:
byte_range += '%d' % (offset + length)
response = self._request('GET', {
'Range': byte_range,
'Accept-Encoding': ', '.join(decode_dict),
})
try:
status = response.status
if status in GOOD_STATUS_SET:
length = response.getheader('content-length')
if (
length is None or
status == httplib.REQUESTED_RANGE_NOT_SATISFIABLE
):
body = b''
else:
encoding = response.getheader(
'content-encoding',
'identity',
).lower()
body = response.read(int(length))
if encoding != 'identity':
body = decode_dict[encoding](body)
self._offset += len(body)
# On python3, response.msg is an email.message.Message
# instance, but not on python2. So align with python2.
encoding_parser = Message()
encoding_parser.add_header(
'content-type',
response.getheader('content-type', 'text/plain'),
)
self.encoding = encoding_parser.get_content_charset(
self.encoding,
)
return body
finally:
response.close()
if status in TEMPFAIL_STATUS_SET:
raise HTTPFileTempFail(status)
raise HTTPFileError(status)
def send(self, message: Message, envelop: Envelop):
message['Subject'] = envelop.subject
message['From'] = envelop.from_addr
message['To'] = envelop.to_addr
if envelop.cc_addr:
message['Cc'] = envelop.cc_addr
if envelop.bcc_addr:
message['Bcc'] = envelop.bcc_addr
if envelop.headers:
for k, v in envelop.headers.items():
if k in message:
message.replace_header(k, v)
else:
message.add_header(k, v)
# https://pybit.es/python-MIME-bcc.html
return self._smtp_sender.send_message(message)
def multipart_form_message(media, form_data={}):
"""Return a MIMEMultipart message to upload encoded media via an HTTP form POST request.
Args:
media: a list of (encoded_data, filename) tuples.
form_data: dict of name, value form fields.
"""
message = MIMEMultipart('form-data', None)
if form_data:
for (name, val) in iteritems(form_data):
part = Message()
part.add_header('Content-Disposition', 'form-data', name=name)
part.set_payload(val)
message.attach(part)
for im, filename in media:
message.attach(form_data_media(im, filename))
return message
def add_dkim_signature(msg: Message, email_domain: str):
if msg["DKIM-Signature"]:
LOG.d("Remove DKIM-Signature %s", msg["DKIM-Signature"])
del msg["DKIM-Signature"]
# Specify headers in "byte" form
# Generate message signature
sig = dkim.sign(
msg.as_string().encode(),
DKIM_SELECTOR,
email_domain.encode(),
DKIM_PRIVATE_KEY.encode(),
include_headers=DKIM_HEADERS,
)
sig = sig.decode()
# remove linebreaks from sig
sig = sig.replace("\n", " ").replace("\r", "")
msg.add_header("DKIM-Signature", sig[len("DKIM-Signature: "):])
def main(config):
"""main routine"""
# Define the emails and couples
# Only one sub-tuple level is supported
emails = config['EMAILS']
couples = config['COUPLES']
sender = config['SENDER']
content = config['CONTENT']
# Find a random possible case
persons = get_persons(couples)
random_case = lets_do_santa_claus_job(couples)
# Send mails
message = Message()
message.add_header('from', sender)
message.add_header('subject','[Confidentiel] Message du Père-Noël')
message.add_header('to', sender)
server = smtplib.SMTP(config['MAIL_HOST'], config['MAIL_PORT'])
server.starttls()
server.login(config['MAIL_USERNAME'], config['MAIL_PASSWORD'])
for i in range(len(persons)):
recipients = emails[persons[i]]
message.replace_header('to', recipients)
message.set_payload(content.format(mail_receiver=persons[i], gift_receiver=random_case[i]))
server.sendmail(sender, [recipients], message.as_string())
print persons[i], ' => ', random_case[i]
server.quit()
def send_sms(data):
text, coding, parts_count = detect_coding(data['text'])
result = {
'sent_text': data['text'],
'parts_count': parts_count,
'mobiles': {}
}
for mobile in data['mobiles']:
# generate message_id
message_id = str(uuid.uuid4())
result['mobiles'][mobile] = {}
result['mobiles'][mobile]['message_id'] = message_id
result['mobiles'][mobile]['dlr_status'] = os.path.join(os.path.dirname(request.url),
os.path.basename(current_app.config['SENT']), message_id)
if not validate_mobile(mobile):
current_app.logger.info('Message from [%s] to [%s] have invalid mobile number' % (auth.username(), mobile))
result['mobiles'][mobile]['response'] = 'Failed: invalid mobile number'
continue
if access_mobile(mobile):
lock_file = os.path.join(current_app.config['OUTGOING'], message_id + '.LOCK')
m = Message()
m.add_header('From', auth.username())
m.add_header('To', mobile)
m.add_header('Alphabet', coding)
if data.get('queue'):
result.update({'queue' : data['queue']})
m.add_header('Queue', result.get('queue'))
m.set_payload(text)
with open(lock_file, write_mode) as fp:
if use_python3:
fp.write(m.as_bytes())
else:
fp.write(m.as_string())
msg_file = lock_file.split('.LOCK')[0]
os.rename(lock_file, msg_file)
os.chmod(msg_file, 0o660)
current_app.logger.info('Message from [%s] to [%s] placed to the spooler as [%s]' % (auth.username(), mobile, msg_file))
result['mobiles'][mobile]['response'] = 'Ok'
else:
current_app.logger.info('Message from [%s] to [%s] have forbidden mobile number' % (auth.username(), mobile))
result['mobiles'][mobile]['response'] = 'Failed: forbidden mobile number'
return result
def toEmail(self):
try:
msg = Message()
msg.add_header('From', self.sender)
msg.add_header('Subject', self.subject)
msg.add_header('Date', str(self.date))
msg.add_header('To', self.receiver)
msg.add_header('Sms-Id', self.sms_id)
msg.set_payload(self.body)
msg.timestamp = time.localtime(self.timestamp)
msg.sms_id = self.sms_id
email.encoders.encode_quopri(msg)
msg.set_charset('utf-8')
return msg
except:
print sender, type(sender)
print receiver
print subject
print timestamp
print sms_id
print body
raise
def _format_msg(self, error_data, to, date, orig):
provider = to.split('@')[1]
msg = Message()
msg.add_header(
'From', 'bitmask-bouncer@localhost (Bitmask Local Agent)')
msg.add_header('To', to)
msg.add_header('Subject', 'Undelivered Message')
msg.add_header('Date', date)
msg.set_payload(BOUNCE_TEMPLATE.format(
raw_error=error_data,
provider=provider,
orig=orig))
return msg.as_string()
def gen_invoice(name, email, rate, fnum):
msg = Message()
msg.add_header('From', 'FCCH Billing <*****@*****.**>')
msg.add_header('To', '"' + name + '" <' + email + '>')
msg.add_header('Cc', '"FCCH Billing" <*****@*****.**>')
msg.add_header('Subject', 'Fort Collins Creator Hub ' + month + ' Invoice')
msg.add_header('Content-type', 'text/plain')
msg.set_payload('''\
Dear %(name)s,
This is a friendly semi-automated reminder that your Fort Collins Creator
Hub monthly membership fee of $%(rate)s for %(month)s is due by the first
of that month. If you've already paid, please do accept my apologies. If
you've configured automatic payment via our credit card billing system or
your bank's billpay, please consider this a reminder that you will soon
be charged.
You can choose to pay by check (or bank billpay) made out to Fort Collins
Creator Hub and sent to:
Fort Collins Creator Hub
PO Box 271094
Fort Collins CO 80527
Or, you can pay by credit card via the Payments page on our website:
http://www.fortcollinscreatorhub.org/
Thanks!
''' % {
'name': name,
'rate': rate,
'month': month,
})
fon = '%04d-%s.email' % (fnum, name.lower().replace(' ', '-'))
fo = open(fon, 'wt')
fo.write(msg.as_string())
fo.close()
def sendmail_sendmail(subject, body, to=USER_EMAIL, from_addr=FROM_EMAIL):
m = Message()
m.add_header('To', to)
m.add_header('Subject', subject)
m.add_header('From', from_addr)
m.set_payload(body)
sendmail = Popen('sendmail -t', stdin=PIPE, shell=True)
sendmail.communicate(input=m.as_string())
def write_line(self, data):
"""
Write a line *data* to socket. It appends a **newline** at
the end of the *data* before sending it.
The string MUST NOT contain **newline** otherwise an AssertionError will
raise.
Parameters:
**data**
String containing the data to be sent.
"""
assert('\n' not in data)
self.write_lock.acquire()
try:
try:
data = data.encode('utf-8')
except AttributeError:
pass
if self._debug_socket:
_log.debug("<:%d: %s", len(data), data.decode('utf-8')[:130])
if self._http:
msg = Message()
msg.add_header('Content-Transfer-Encoding', '8bit')
msg.add_header('Content-Type', 'application/json-rpc')
msg.add_header('Content-Length', str(len(data)))
msg.set_payload(data, charset='utf-8')
self._wbuffer += 'HTTP/1.0 200 OK\n'+msg.as_string()
#print(self._wbuffer)
else:
self._wbuffer += data + b'\n'
sbytes = 0
while self._wbuffer:
try:
sbytes = self._sck.send(self._wbuffer)
except IOError:
_log.debug("Write socket error: IOError (timeout: %r)",
self._sck.gettimeout())
_log.debug(traceback.format_exc(0))
return 0
except socket.error:
_log.debug("Write socket error: socket.error (timeout: %r)",
self._sck.gettimeout())
_log.debug(traceback.format_exc(0))
return 0
except:
raise
if sbytes == 0:
break
self._wbuffer = self._wbuffer[sbytes:]
if self._wbuffer:
_log.warning("%d bytes left in write buffer", len(self._wbuffer))
return len(self._wbuffer)
finally:
self.write_lock.release()
def limit_reached_alert(user, limit_type, limit, value):
"""
Send out a notification when a limit is reached.
:param user: The user who has hit the limit
:type user: User
:param limit_type: The type of limit that has been reached
:type limit_type: str
:param limit: The limit amount
:type limit: int
:param value: The number of messages sent
:type value: int
"""
name = get_config('alerts_name')
faddr = get_config('alerts_from')
taddr = get_config('alerts_to')
message = MIMEMessage()
message.add_header('From', '"%s" <%s>' % (name, faddr))
if isinstance(taddr, list):
message.add_header('To', ', '.join(taddr))
else:
message.add_header('To', taddr)
message.add_header('Date', formatdate())
message.add_header('Subject', 'User %s reached sending limit' % user.email)
message.set_payload("""Hi,
The user has reached their %s limit of sending messages. They have sent %d
messages and have a limit of %d""" % (limit_type, value, limit)
)
# Send the message to the local SMTP server
smtp = smtplib.SMTP('localhost')
smtp.sendmail(faddr, taddr, str(message))
smtp.close()
def send_mail(nick_name, receivers, subject, content):
server = smtplib.SMTP(smtp_server, smtp_port)
server.login(user, passwd)
rec_list = [rec for rec in receivers.split(";") if rec.find("@") != -1]
msg = Message()
msg.add_header("from", formataddr((nick_name, sender)))
for rec in rec_list:
msg.add_header("to", rec)
msg.add_header("subject", subject)
msg.set_payload(content)
logger.debug("mail:%s"%msg.as_string())
server.sendmail(sender, rec_list, msg.as_string())
server.close()
def send(self, url):
msg = Message()
msg.add_header('From', '%s %s' % (self.name, self.email))
for to in self.recipients:
msg.add_header('To', to)
msg.add_header('Subject', self.subject)
msg.set_payload(self.status.getvalue())
try:
mailer = smtplib.SMTP(self.host, self.port)
except socket.error, e:
error = 'Error initializing SMTP host. If you are using localhost, make sure that sendmail is properly configured.\nError message: %s' % e
log.error(error)
raise Exception(error)
sys.exit(-1)
def send_email(email_msg, subject):
to = ['*****@*****.**','*****@*****.**','*****@*****.**','*****@*****.**', '*****@*****.**']
msg = Message()
msg.add_header('From', 'Diederik van Liere <*****@*****.**>')
for t in to:
msg.add_header('To', t)
msg.add_header('Subject', subject)
msg.set_payload(email_msg.getvalue())
mailer = smtplib.SMTP("smtp.gmail.com", 587)
mailer.ehlo()
mailer.starttls()
mailer.ehlo()
mailer.login(gmail_user, gmail_pwd)
mailer.sendmail('*****@*****.**', to, msg.as_string())
# Should be mailer.quit(), but that crashes...
mailer.close()
