def send_email(address,message):
"""Send an email to the address saying that prepration for the dir is done"""
import smtplib
from email.MIMEText import MIMEText
from email.MIMEMultipart import MIMEMultipart
from email.MIMENonMultipart import MIMENonMultipart
from email.MIMEBase import MIMEBase
from email import Encoders
import mimetypes
#
# Prepare the message
#
text=message
text_mes=MIMEText(text)
message=MIMEMultipart()
message.preamble='pKD message'
message.epilogue = ''
message['Subject']='Message from pKD server'
message['From']='pKD Server <*****@*****.**>'
message['Reply-To']='*****@*****.**'
message['To']=address
message.attach(text_mes)
#
# Send the email
#
#sys.stdout=X
try:
server=smtplib.SMTP('193.1.169.34') #mail.ucd.ie
server.set_debuglevel(1)
server.login('jensniel','alpha2')
server.sendmail('*****@*****.**',address,message.as_string())
server.quit()
except:
pass
return
def compose(self, From, To, body, attaches, **headers):
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from email.MIMEBase import MIMEBase
from email.Encoders import encode_base64
message = MIMEMultipart()
message['To'] = formataddr(To, self.charset)
message['From'] = formataddr(From, self.charset)
self._setHeaders(message, **headers)
message.preamble = "Multipart message"
message.epilogue = ""
body = isinstance(body, unicode) and body.encode(self.charset) or body
text = MIMEText(body, _charset=self.charset)
message.attach(text)
for ctype, filename, fileobj in attaches:
maintype, subtype = ctype.split('/', 1)
attach = MIMEBase(maintype, subtype)
attach.set_payload(fileobj.read())
encode_base64(attach)
attach.add_header("Content-Disposition", "attachment", filename=filename)
message.attach(attach)
return message
def send_email_to_list(debug,line,fromaddr,template,smtp_server,msgsubject,username,password):
replyto = fromaddr
htmlmsgtext = template
try:
msgtext = htmlmsgtext.replace('<b>','').replace('</b>','').replace('<br>',"\r").replace('</br>',"\r").replace('<br/>',"\r").replace('</a>','')
msgtext = re.sub('<.*?>','',msgtext)
msg = MIMEMultipart()
msg.preamble = 'This is a multi-part message in MIME format.\n'
msg.epilogue = ''
body = MIMEMultipart('alternative')
body.attach(MIMEText(msgtext))
body.attach(MIMEText(htmlmsgtext, 'html'))
msg.attach(body)
msg.add_header('From', fromaddr)
msg.add_header('To', line)
msg.add_header('Subject', msgsubject)
msg.add_header('Reply-To', replyto)
server = smtplib.SMTP(smtp_server)
if debug == True:
server.set_debuglevel(True)
server.starttls()
server.login(username,password)
server.sendmail(msg['From'], [msg['To']], msg.as_string())
print ">sent to: ",line
server.quit()
print ">closed session"
print ">sleeping, dont want to flood smtp server"
time.sleep(1)
except Exception,e:
print str(e)
print ">error sending email ",line
def send_email_csv_attach(toaddrs, mail, csv_fn, fromaddr=EMAIL_SENDER_ADDR):
msg = MIMEMultipart()
msg['From'] = fromaddr
msg['To'] = toaddrs
msg['Subject'] = 'please check attached csv file for cr status'
msg.preamble = 'You will not see this in a MIME-aware mail reader.\n'
# To guarantee the message ends with a newline
msg.epilogue = ''
#body
text = MIMEText(mail)
msg.attach(text)
#attachment
csv = MIMEBase('text', 'x-comma-separated-values')
fp = open(csv_fn, 'rb')
csv.set_payload(fp.read())
Encoders.encode_base64(csv)
csv.add_header('Content-Disposition', 'attachment', filename=os.path.basename(csv_fn))
msg.attach(csv)
server = smtplib.SMTP('remotesmtp.mot.com')
server.set_debuglevel(1)
server.sendmail(fromaddr, toaddrs, msg.as_string())
server.quit()
def emailFile(to,
subject,
message,
filePath,
mimeType=None,
fromEmail=FROMEMAIL,
server=SERVER):
"""
sends an email attachment to the given address or list of addesses.
if the mimeType is not specified, it uses mimetypes.guess_type to determine it.
"""
toList, to = processTo(to)
msg = MIMEMultipart()
msg['Subject'] = subject
msg['To'] = to
msg['From'] = fromEmail
msg['Date'] = formatdate()
msg.preamble = 'You are not using a MIME-aware reader\n'
msg.epilogue = ''
#add the main message
msg.attach(MIMEText(message))
if type(filePath) is list:
for f in filePath:
addFile(f, msg, mimeType)
else:
addFile(filePath, msg, mimeType)
rawEmail(toList, msg.as_string(), server=server, fromEmail=fromEmail)
def emailAggregatorPage(from_addr, to_addr, subj, smtp_host, out_fn):
"""
Read in the HTML page produced by an aggregator run, construct a
MIME-Multipart email message with the HTML attached, and send it off
with the given from, to, and subject headers using the specified
SMTP mail server.
"""
# Begin building the email message.
msg = MIMEMultipart()
msg['To'] = to_addr
msg['From'] = from_addr
msg['Subject'] = subj
msg.preamble = "You need a MIME-aware mail reader.\n"
msg.epilogue = ""
# Generate a plain text alternative part.
plain_text = """
This email contains entries from your subscribed feeds in HTML.
"""
part = MIMEText(plain_text, "plain", UNICODE_ENC)
msg.attach(part)
# Generate the aggregate HTML page, read in the HTML data, attach it
# as another part of the email message.
html_text = open(out_fn).read()
part = MIMEText(html_text, "html", UNICODE_ENC)
msg.attach(part)
# Finally, send the whole thing off as an email message.
print "Sending email '%s' to '%s'" % (subj, to_addr)
s = smtplib.SMTP(smtp_host)
s.sendmail(from_addr, to_addr, msg.as_string())
s.close()
def construct_email_message(sender, to_list, cc_list, subject, mtext,
attachment_list):
"""
#
"""
outer = MIMEMultipart()
outer['From'] = sender
outer['To'] = ', '.join(to_list)
outer['Cc'] = ', '.join(cc_list)
outer['Subject'] = subject
outer.preample = 'You will not see this in a MIME-aware mail reader.\n'
outer.epilogue = ''
# plain text body
msg = MIMEText(mtext + '\n\n')
msg.add_header('Content-Disposition', 'inline')
outer.attach(msg)
# file attachments
# outer.add_header('Content-Transfer-Encoding', 'base64')
for att in attachment_list:
if not os.path.isfile(att):
continue
ctype, encoding = mimetypes.guess_type(att)
maintype, subtype = ctype.split('/', 1)
fp = open(att, 'rb')
msg = MIMEBase(maintype, subtype)
# msg = MIMEBase('application', 'octet-stream')
msg.set_payload(fp.read())
Encoders.encode_base64(msg)
basename = att.split('/')[-1]
msg.add_header('Content-Disposition', 'attachment', filename=basename)
outer.attach(msg)
return outer
def prepare_email_message(self):
plain = self.plain
if not plain:
return None
# We definitely want unicode at this point.
plain = su(plain)
# We must choose the body charset manually. Note that the
# goal and effect of this loop is to determine the
# body_charset.
for body_charset in "US-ASCII", get_charset(), "UTF-8":
try:
plain.encode(body_charset)
except UnicodeEncodeError:
pass
else:
break
# Encoding should work now; let's replace errors just in case.
plain = plain.encode(body_charset, "replace")
text_part = MIMEText(plain, "plain", body_charset)
email_msg = MIMEMultipart("alternative")
email_msg.epilogue = ""
email_msg.attach(text_part)
return email_msg
def emailAggregatorPage(from_addr, to_addr, subj, smtp_host, out_fn):
"""
Read in the HTML page produced by an aggregator run, construct a
MIME-Multipart email message with the HTML attached, and send it off
with the given from, to, and subject headers using the specified
SMTP mail server.
"""
# Begin building the email message.
msg = MIMEMultipart()
msg['To'] = to_addr
msg['From'] = from_addr
msg['Subject'] = subj
msg.preamble = "You need a MIME-aware mail reader.\n"
msg.epilogue = ""
# Generate a plain text alternative part.
plain_text = """
This email contains entries from your subscribed feeds in HTML.
"""
part = MIMEText(plain_text, "plain", UNICODE_ENC)
msg.attach(part)
# Generate the aggregate HTML page, read in the HTML data, attach it
# as another part of the email message.
html_text = open(out_fn).read()
part = MIMEText(html_text, "html", UNICODE_ENC)
msg.attach(part)
# Finally, send the whole thing off as an email message.
print "Sending email '%s' to '%s'" % (subj, to_addr)
s = smtplib.SMTP(smtp_host)
s.sendmail(from_addr, to_addr, msg.as_string())
s.close()
def smtp_process(self, alstr_to, astr_from, astr_subject, astr_body,
alstr_attach):
#
# PRECONDITIONS
# o Should only be called by one of the send() methods
# o Assumes that any attachments are valid files
#
# POSTCONDITIONS
# o Interacts with the SMTPlib module
#
self.internals_check()
print astr_from
msg = MIMEMultipart()
msg['Subject'] = astr_subject
msg['From'] = astr_from
msg.preamble = "This is a mult-part message in MIME format."
msg.attach(MIMEText(astr_body))
msg.epilogue = ''
for file in alstr_attach:
fp = open(file, 'rb')
img = MIMEImage(fp.read())
img.add_header('Content-ID', file)
fp.close()
msg.attach(img)
smtp = smtplib.SMTP()
smtp.connect(self.mstr_SMTPserver)
for str_to in alstr_to:
msg['To'] = str_to
smtp.sendmail(astr_from, str_to, msg.as_string())
smtp.close()
def prepare_email_message(mensagem, html=False):
email = su(mensagem)
# We must choose the body charset manually. Note that the
# goal and effect of this loop is to determine the
# body_charset.
for body_charset in 'US-ASCII', get_charset(), 'UTF-8':
try:
email.encode(body_charset)
except UnicodeEncodeError:
pass
else:
break
# Encoding should work now; let's replace errors just in case.
if html:
email = email.encode(body_charset, 'xmlcharrefreplace')
text_part = MIMEText(email, 'html', body_charset)
else:
email = email.encode(body_charset, 'replace')
text_part = MIMEText(email, 'plain', body_charset)
# Okay, we send both plain text and html
email_msg = MIMEMultipart('alternative')
email_msg.epilogue = ''
email_msg.attach(text_part)
return email_msg
def send_from_gmail(email, body, subject):
''' Send email from gmail.'''
server = SMTP('smtp.gmail.com', 587)
## server.set_debuglevel(1)
server.ehlo()
server.starttls()
server.ehlo()
server.login(EMAIL_LOGIN, EMAIL_PASSWORD)
# Create the enclosing (outer) message
outer = MIMEMultipart()
outer['Subject'] = subject
outer['To'] = email
outer['From'] = EMAIL_LOGIN
outer.preamble = '\n'
# To guarantee the message ends with a newline
outer.epilogue =''
# Note: we should handle calculating the charset
msg = MIMEText(body)
# Message body
outer.attach(msg)
text = outer.as_string()
server.sendmail(outer['From'], outer['To'], text)
# SSL error because of bad comunication closing
try:
server.quit()
except:
pass
def send_email(address, message):
"""Send an email to the address saying that prepration for the dir is done"""
import smtplib
from email.MIMEText import MIMEText
from email.MIMEMultipart import MIMEMultipart
from email.MIMENonMultipart import MIMENonMultipart
from email.MIMEBase import MIMEBase
from email import Encoders
import mimetypes
#
# Prepare the message
#
text = message
text_mes = MIMEText(text)
message = MIMEMultipart()
message.preamble = 'pKD message'
message.epilogue = ''
message['Subject'] = 'Message from pKD server'
message['From'] = 'pKD Server <*****@*****.**>'
message['Reply-To'] = '*****@*****.**'
message['To'] = address
message.attach(text_mes)
#
# Send the email
#
#sys.stdout=X
try:
server = smtplib.SMTP('193.1.169.34') #mail.ucd.ie
server.set_debuglevel(1)
server.login('jensniel', 'alpha2')
server.sendmail('*****@*****.**', address, message.as_string())
server.quit()
except:
pass
return
def sendMultipartMail(context,
from_,
to,
cc=[],
bcc=[],
subject="",
text="",
charset="utf-8"):
"""
"""
mail = MIMEMultipart("alternative")
mail['From'] = from_
mail['To'] = to
mail['Bcc'] = "".join(cc)
mail['Bcc'] = "".join(bcc)
mail['Subject'] = subject
mail.epilogue = ''
# create & attach text part
text = text.encode("utf-8")
text_part = MIMEText(text, "plain", charset)
mail.attach(text_part)
# create & attach html part with images
html_part = MIMEMultipart("related")
html_code = MIMEText(text, "html", charset)
html_part.attach(html_code)
mail.attach(html_part)
context.MailHost.send(mail.as_string())
def emailFile(to, subject, message, filePath, mimeType=None, fromEmail=FROMEMAIL, server=SERVER):
"""
sends an email attachment to the given address or list of addesses.
if the mimeType is not specified, it uses mimetypes.guess_type to determine it.
"""
toList, to = processTo(to)
msg = MIMEMultipart()
msg['Subject'] = subject
msg['To'] = to
msg['From'] = fromEmail
msg['Date'] = formatdate()
msg.preamble = 'You are not using a MIME-aware reader\n'
msg.epilogue = ''
#add the main message
msg.attach(MIMEText(message))
if type(filePath) is list:
for f in filePath:
addFile(f, msg, mimeType)
else:
addFile(filePath, msg, mimeType)
rawEmail(toList, msg.as_string(), server=server, fromEmail=fromEmail)
def send_mail(self, mail_data):
if self.email_send:
print 'Sending traceback via mail ...'
else:
print mail_data
return
subject = self.mail_subject
sender = self.mail_from
recipients = self.mail_to
encoding = 'iso-8859-1'
if not mail_data:
return
msg = MIMEMultipart("alternative")
msg['Subject'] = Header(subject, encoding)
msg['To'] = str(recipients)[1:-1].replace('\'','')
msg['MIME-Version'] = "1.0"
msg.epilogue = ''
textPart = MIMEText(mail_data,encoding)
msg.attach(textPart)
server = smtplib.SMTP(self.smtp_server)
try:
server.sendmail(sender, recipients, msg.as_string())
except smtplib.SMTPRecipientsRefused,msg:
print 'mail was refused by smtp server'
def send(self, rcpt, mime_headers={}):
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from email.Header import Header
from email.Utils import formatdate
body = self.hdf.render(self.template_name)
msg = MIMEMultipart()
msg.attach(MIMEText(body, 'plain', 'utf-8'))
msg.epilogue = ''
msg['X-Mailer'] = 'Trac %s, by Edgewall Software' % __version__
msg['X-Trac-Version'] = __version__
projname = self.config.get('project', 'name')
msg['X-Trac-Project'] = projname
msg['X-URL'] = self.config.get('project', 'url')
msg['Subject'] = Header(self.subject, 'utf-8')
msg['From'] = '%s <%s>' % (projname, self.from_email)
msg['Sender'] = self.from_email
msg['Reply-To'] = self.replyto_email
msg['To'] = rcpt
msg['Date'] = formatdate()
for hdr in mime_headers.keys():
msg[hdr] = mime_headers[hdr]
self.env.log.debug("Sending SMTP notification to %s on port %d" %
(self.smtp_server, self.smtp_port))
self.server.sendmail(self.from_email, [rcpt], msg.as_string())
def send_email(debug,toaddr2,msgsubject,fromaddr,template,smtp_server,username,password):
replyto = fromaddr
htmlmsgtext = template
msgtext = htmlmsgtext.replace('<b>','').replace('</b>','').replace('<br>',"\r").replace('</br>',"\r").replace('<br/>',"\r").replace('</a>','')
msgtext = re.sub('<.*?>','',msgtext)
msg = MIMEMultipart()
msg.preamble = 'This is a multi-part message in MIME format.\n'
msg.epilogue = ''
body = MIMEMultipart('alternative')
body.attach(MIMEText(msgtext))
body.attach(MIMEText(htmlmsgtext, 'html'))
msg.attach(body)
msg.add_header('From', fromaddr)
msg.add_header('To', toaddr2)
msg.add_header('Subject', msgsubject)
msg.add_header('Reply-To', replyto)
server = smtplib.SMTP(smtp_server)
if debug == True:
server.set_debuglevel(True)
server.starttls()
server.login(username,password)
server.sendmail(msg['From'], [msg['To']], msg.as_string())
print ">sent email"
server.quit()
print ">closed session"
def __createMultipartMail(self):
"""
Private method to create a multipart mail message.
@return string containing the mail message
"""
try:
import sipconfig
sip_version_str = sipconfig.Configuration().sip_version_str
except ImportError:
sip_version_str = "sip version not available"
mpPreamble = (
"This is a MIME-encoded message with attachments. "
"If you see this message, your mail client is not "
"capable of displaying the attachments."
)
msgtext = "%s\r\n----\r\n%s----\r\n%s----\r\n%s" % (
unicode(self.message.toPlainText()),
Utilities.generateVersionInfo("\r\n"),
Utilities.generatePluginsVersionInfo("\r\n"),
Utilities.generateDistroInfo("\r\n"),
)
# first part of multipart mail explains format
msg = MIMEMultipart()
msg["From"] = unicode(Preferences.getUser("Email"))
msg["To"] = self.__toAddress
msg["Subject"] = "[eric4] %s" % unicode(self.subject.text())
msg.preamble = mpPreamble
msg.epilogue = ""
# second part is intended to be read
att = MIMEText(msgtext, _charset=unicode(Preferences.getSystem("StringEncoding")))
msg.attach(att)
# next parts contain the attachments
for index in range(self.attachments.topLevelItemCount()):
itm = self.attachments.topLevelItem(index)
maintype, subtype = str(itm.text(1)).split("/", 1)
fname = unicode(itm.text(0))
name = os.path.basename(fname)
if maintype == "text":
att = MIMEText(open(fname, "rb").read(), _subtype=subtype)
elif maintype == "image":
att = MIMEImage(open(fname, "rb").read(), _subtype=subtype)
elif maintype == "audio":
att = MIMEAudio(open(fname, "rb").read(), _subtype=subtype)
else:
att = MIMEBase(maintype, subtype)
att.set_payload(open(fname, "rb").read())
Encoders.encode_base64(att)
att.add_header("Content-Disposition", "attachment", filename=name)
msg.attach(att)
return msg.as_string()
def createEnvelop(self, source, destination, subject):
envelop = MIMEMultipart()
envelop['From'] = source
envelop['To'] = destination
envelop['Subject'] = subject
envelop.epilogue = '' # make sure it ends with a newline
return envelop
def createEnvelop(self, source, destination, subject):
envelop = MIMEMultipart()
envelop['From'] = source
envelop['To'] = destination
envelop['Subject'] = subject
envelop.epilogue = '' # make sure it ends with a newline
return envelop
def sendEmail(self, addresses, subject, body):
"""
send email from address book.
"""
if not addresses:
return
portal_url = getToolByName(self, 'portal_url')
portal = portal_url.getPortalObject()
plone_utils = getToolByName(self, 'plone_utils')
mailHost = plone_utils.getMailHost()
# preparing the from address.
charset = portal.getProperty('email_charset', None)
if charset is None or charset == '':
charset = plone_utils.getSiteEncoding()
fromAddress = portal.getProperty('email_from_address', None)
if fromAddress is None:
self.log.error(
'Cannot send notification email: email sender address not set')
return
fromName = portal.getProperty('email_from_name', None)
if fromName is not None:
fromAddress = "%s <%s>" % (fromName, fromAddress)
if isinstance(fromAddress, unicode):
fromAddress = fromAddress.encode(charset, 'replace')
# for testing only!
#fromAddress = 'web master <*****@*****.**>'
email = MIMEMultipart('alternative')
email.epilogue = ''
# preparing the email message
if isinstance(body, unicode):
body = body.encode(charset, 'replace')
textPart = MIMEText(body, 'plain', charset)
email.attach(textPart)
# the html format.
htmlPart = MIMEText(body, 'html', charset)
email.attach(htmlPart)
message = str(email)
if isinstance(subject, unicode):
subject = subject.encode(charset, 'replace')
for address in addresses:
if isinstance(address, unicode):
address = address.encode(charset, 'replace')
try:
mailHost.send(message=message,
mto=address,
mfrom='David <*****@*****.**>',
subject=subject)
except ConflictError:
raise
except:
self.log.error('Sending email error for %s!' % (address))
def httprequest(self, postdata):
if not self.anubisURL.startswith("http://"):
raise "Invalid URL, only http:// URLs are allowed: url='%s'" % (
self.anubisURL)
if not postdata:
raise "Invalid/No POST data supplied: postdata='%s'" % (postdata)
headers = {}
headers["Content-Type"] = "multipart/form-data"
message = MIMEMultipart(_subtype="form-data")
### notification element
part = MIMEText(None)
part.set_payload(postdata["notification"], "us-ascii")
part.add_header("Content-Disposition",
"form-data",
name="notification")
message.attach(part)
### email element
part = MIMEText(None)
part.set_payload(postdata["email"], "us-ascii")
part.add_header("Content-Disposition", "form-data", name="email")
message.attach(part)
### type element
part = MIMEText(None)
part.set_payload(postdata["analysisType"], "us-ascii")
part.add_header("Content-Disposition",
"form-data",
name="analysisType")
message.attach(part)
### file data element
part = MIMEBase('application', "octet-stream")
part.set_payload(postdata['executable']['content'])
### Add content-disposition header.
dispHeaders = postdata["executable"].get("headers", {})
part.add_header("Content-Disposition",
"form-data",
name="executable",
filename=postdata["executable"]["filename"])
for dhName, dhValue in dispHeaders:
part.add_header(dhName, dhValue)
message.attach(part)
message.epilogue = ""
headerBlock, body = message.as_string().split("\n\n", 1)
for hName, hValue in message.items():
headers[hName] = hValue
### Make the HTTP request and get the response.
### Precondition: 'url', 'method', 'headers', 'body' are all setup properly.
scheme, netloc, path, parameters, query, fragment = urlparse.urlparse(
self.anubisURL)
if parameters or query or fragment:
raise "Unexpected URL: parameters=%r, query=%r, fragment=%r" % (
parameters, query, fragment)
try:
conn = httplib.HTTPConnection(netloc)
conn.request("POST", path, body, headers)
response = conn.getresponse()
except socket.error, e:
response = ConnRes(404, e)
def prepare_mail_message(msg, attachment, filename):
""" Creates the message
"""
html = msg
# First, we transform the message in a text format.
portal_transforms = getToolByName(getSite(),
'portal_transforms')
plain = portal_transforms.convert('html_to_text',
html).getData()
# We definitely want unicode at this point.
plain = su(plain)
html = su(html)
# We must choose the body charset manually. Note that the
# goal and effect of this loop is to determine the
# body_charset.
for body_charset in 'US-ASCII', get_charset(), 'UTF-8':
try:
plain.encode(body_charset)
html.encode(body_charset)
except UnicodeEncodeError:
pass
else:
break
# Encoding should work now; let's replace errors just in case.
plain = plain.encode(body_charset, 'replace')
html = html.encode(body_charset, 'xmlcharrefreplace')
text_part = MIMEText(plain, 'plain', body_charset)
html_part = MIMEText(html, 'html', body_charset)
# As we have plain text, html and attachment, we need to do
# two multiparts:
# - the first one contains the message
# the second one includes the previous one and the attachment.
email_content = MIMEMultipart('alternative')
email_content.epilogue = ''
email_content.attach(text_part)
email_content.attach(html_part)
# Now the attachment.
attach = MIMEBase('application', 'pdf')
attach.set_payload(attachment.read())
Encoders.encode_base64(attach)
attach.add_header('Content-Disposition',
'attachment; filename="%s"' % filename)
# We attach everything to the mail.
email_msg = MIMEMultipart()
email_msg.attach(email_content)
email_msg.attach(attach)
return email_msg
def main(argv):
is_looping = False
root_path = "./"
move_path = None
fail_path = DEFAULT_FAIL_PATH
try:
opts, args = getopt.getopt(argv, "i:o:f:l")
except getopt.GetoptError:
usage()
sys.exit(2)
for opt, arg in opts:
if opt == "-i":
root_path += arg
elif opt == "-o":
move_path = "./" + arg
elif opt == "-f":
fail_path = "./" + arg
elif opt == "-l":
is_looping = True
msg = "Importer naturally stopped."
logger.info("Importer started with input=" + root_path + ", output=" +
str(move_path) + ", fail=" + fail_path + ", loop=" +
str(is_looping))
try:
while True:
print "Importing..."
parser_findzip(root_path, move_path, fail_path, is_looping)
if (False == is_looping):
break
print "Waiting..."
time.sleep(10)
except:
msg = traceback.format_exc()
print msg
if (False == is_looping):
return
logger.info("Mailing...")
mail_obj = MIMEMultipart()
mail_obj['Subject'] = EMAIL_SUBJECT
mail_obj['From'] = EMAIL_FROM
mail_obj['To'] = listToStr(EMAIL_RECEIVERS)
mail_obj.preamble = "This is a multi-part message in MIME format."
mail_obj.epilogue = ''
msg_txt = MIMEText(msg)
msg_txt.replace_header('Content-Type', 'text/html; charset="big5"')
mail_obj.attach(msg_txt)
msg_body = mail_obj.as_string()
smtpObj = smtplib.SMTP('relay-b.pegatroncorp.com')
smtpObj.sendmail(EMAIL_FROM, EMAIL_RECEIVERS, msg_body)
smtpObj.quit()
def sendAlarm( context, subj, txt ):
import sco_utils
msg = MIMEMultipart()
subj = Header( subj, sco_utils.SCO_ENCODING )
msg['Subject'] = subj
msg['From'] = context.get_preference('email_from_addr')
msg['To'] = ALARM_DESTINATION
msg.epilogue = ''
txt = MIMEText( txt, 'plain', sco_utils.SCO_ENCODING )
msg.attach(txt)
context.sendEmail(msg)
def sys_adm_notify(db, param):
"""This program sends notifications of messages to sys admins"""
new_messages = dbobj.sys_admin_msg_list(db, status='N')
sysadmins = dbobj.sys_admin_list(db)
for sa in sysadmins:
send_mail = 0
body = tag('H1', param.title)
body += "<H4>The following messages have been received and await your attention</H4>"
body = tag('A', body, 'href=' + param.baseurl + param.pythondir + '/office.py?jw_action=sys_admf_msg')
for msg in new_messages.messagelist:
send_mail = 1
line = tag('A', msg.body, 'href=' + param.baseurl + param.pythondir + '/office.py?jw_action=sys_admf_disp&msg_id=' + str(msg.msg_id))
line += ' From: ' + msg.name + '<BR>'
body += line
if send_mail:
# Create the mail message
outer = MIMEMultipart()
# Mail headers
outer['Subject'] = 'You have new messages from ' + param.title
outer['From'] = param.fromaddr
outer['To'] = sa.email
outer.preamble = 'Notification of messages'
outer.epilogue = ''
#Add the html header
textfile = param.template_dir + '/' + param.email_header
mf = open(textfile)
msg_body = mf.read()
mf.close()
#Add the body of the email
msg_body += body
#Add the footer of the email
textfile = param.template_dir + '/' + param.email_footer
mf = open(textfile)
msg_body += mf.read()
mf.close()
msgfile = MIMEText(msg_body, 'html')
outer.attach(msgfile)
mailserver = smtplib.SMTP(param.smtpserver)
#mailserver.set_debuglevel(1)
mailserver.sendmail(param.fromaddr, sa.email, outer.as_string())
mailserver.quit()
return
def sendMail(subject,
body,
attachments = [],
status = False,
from_mail = '*****@*****.**',
to_mail = [ '*****@*****.**' ],
smtp_host = ''):
if attachments:
msg = MIMEMultipart()
else:
msg = Message()
msg['Subject'] = subject
msg['From'] = from_mail
msg['To'] = ', '.join(to_mail)
msg['X-ERP5-Tests'] = 'ERP5'
if status:
msg['X-ERP5-Tests-Status'] = 'OK'
# Guarantees the message ends in a newline
msg.preamble = subject
msg.epilogue = ''
if attachments:
mime_text = MIMEText(body)
mime_text.add_header('Content-Disposition', 'attachment',
filename='body')
msg.attach(mime_text)
html_re = re.compile('<html>', re.I)
for item in attachments:
mime_text = MIMEText(item)
if html_re.match(item):
mime_text.set_type('text/html')
mime_text.add_header('Content-Disposition', 'attachment',
filename='attachment.html')
else:
mime_text.add_header('Content-Disposition', 'attachment',
filename='attachment.txt')
msg.attach(mime_text)
else:
msg.set_payload(body)
# Send the email via SMTP server.
if smtp_host:
s = smtplib.SMTP(smtp_host)
else:
s = smtplib.SMTP()
s.connect()
s.sendmail(from_mail, to_mail, msg.as_string())
s.close()
def send(self,fromaddr,toaddr,msgsubject = '',msg='',attachments=[]):
replyto = fromaddr
self.htmlmsgtext=msg
try:
# Make text version from HTML - First convert tags that produce a line break to carriage returns
msgtext = self.htmlmsgtext.replace('</br>',"\r").replace('<br />',"\r").replace('</p>',"\r")
# Then strip all the other tags out
msgtext = self.strip_tags(msgtext)
# necessary mimey stuff
msg = MIMEMultipart()
msg.preamble = ''
msg.epilogue = ''
body = MIMEMultipart('alternative')
body.attach(MIMEText(msgtext))
body.attach(MIMEText(self.htmlmsgtext, 'html'))
msg.attach(body)
if 'attachments' in globals() and len('attachments') > 0: # are there attachments?
for filename in attachments:
f = filename
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)
msg.add_header('From', fromaddr)
msg.add_header('To', toaddr)
msg.add_header('Subject', msgsubject)
msg.add_header('Reply-To', replyto)
# The actual email sendy bits
server = smtplib.SMTP(host)
server.set_debuglevel(False) # set to True for verbose output
try:
# gmail expect tls
server.starttls()
server.login(self.username,self.password)
server.sendmail(msg['From'], [msg['To']], msg.as_string())
print 'Email sent'
server.quit() # bye bye
except:
# if tls is set for non-tls servers you would have raised an exception, so....
server.login(username,password)
server.sendmail(msg['From'], [msg['To']], msg.as_string())
print 'Email sent'
server.quit() # sbye bye
except:
print ('Email NOT sent to %s successfully. %s ERR: %s %s %s ', str(toaddr), 'tete', str(sys.exc_info()[0]), str(sys.exc_info()[1]), str(sys.exc_info()[2]) )
def mail_password(u, context=None, reset=False):
"Send password by email"
if not u['email']:
return
u['url'] = context.ScoURL()
txt = """
Bonjour %(prenom)s %(nom)s,
""" % u
if reset:
txt += """
votre mot de passe ScoDoc a été ré-initialisé.
Le nouveau mot de passe est: %(passwd)s
Votre nom d'utilisateur est %(user_name)s
Vous devrez changer ce mot de passe lors de votre première connexion
sur %(url)s
""" % u
else:
txt += """
vous avez été déclaré comme utilisateur du logiciel de gestion de scolarité ScoDoc.
Votre nom d'utilisateur est %(user_name)s
Votre mot de passe est: %(passwd)s
Le logiciel est accessible sur: %(url)s
Vous êtes invité à changer ce mot de passe au plus vite (cliquez sur
votre nom en haut à gauche de la page d'accueil).
""" % u
txt += """
ScoDoc est un logiciel libre développé à l'Université Paris 13 par Emmanuel Viennet.
Pour plus d'informations sur ce logiciel, voir %s
""" % SCO_WEBSITE
msg = MIMEMultipart()
if reset:
msg['Subject'] = Header( 'Mot de passe ScoDoc', SCO_ENCODING )
else:
msg['Subject'] = Header( 'Votre accès ScoDoc', SCO_ENCODING )
msg['From'] = context.get_preference('email_from_addr')
msg['To'] = u['email']
msg.epilogue = ''
txt = MIMEText( txt, 'plain', SCO_ENCODING )
msg.attach(txt)
context.sendEmail(msg)
def send_email(self, context, request, receipt):
title = context.Title()
description = context.Description()
body_html = u'<html><div class="mailcontent"><h1 class="documentFirstHeading">' + title.decode('utf-8') + u'</h1><div class="documentDescription description">' + description.decode('utf-8') + u'</div>' + context.text.output + u'</div></html>'
#for 'non HTML mail clients'
transforms = api.portal.get_tool(name='portal_transforms')
stream = transforms.convertTo('text/plain', body_html, mimetype='text/html')
body_plain = stream.getData().strip()
messages = IStatusMessage(self.request)
# ready to create multipart mail
try:
mailhost = api.portal.get_tool(name='MailHost')
# discovered that plone api might do this better
# plone.api.portal.send_email , maybe
outer = MIMEMultipart('alternative')
outer['To'] = receipt
outer['From'] = api.portal.get_registry_record('plone.email_from_address')
outer['Subject'] = title
outer.epilogue = ''
# Attach text part
text_part = MIMEText(body_plain, 'plain', _charset='UTF-8')
# Attach html part with images
html_part = MIMEMultipart('related')
html_text = MIMEText(body_html, 'html', _charset='UTF-8')
html_part.attach(html_text)
# Add images to the message
#for image in issue_data['images_to_attach']:
# html_part.attach(image)
outer.attach(text_part)
outer.attach(html_part)
mailhost.send(outer.as_string())
messages.add(_("sent_mail_message", default=u"Sendt til $email",
mapping={'email': receipt },
),
type="info")
except:
messages.add(_("cant_send_mail_message",
default=u"Kunne ikke sende til $email",
mapping={'email': receipt },
),
type="warning")
def notify_mail(msg):
mail_obj = MIMEMultipart()
mail_obj['Subject'] = EMAIL_SUBJECT
mail_obj['From'] = private.mail_from_addr
mail_obj['To'] = listToStr(private.get_mail_list())
mail_obj.preamble = "This is a multi-part message in MIME format."
mail_obj.epilogue = ''
msg_txt = MIMEText(msg.replace("\n", "<br>"))
msg_txt.replace_header('Content-Type', 'text/html; charset="big5"')
mail_obj.attach(msg_txt)
msg_body = mail_obj.as_string()
smtpObj = smtplib.SMTP(private.mail_server_addr)
smtpObj.sendmail(private.mail_from_addr, private.get_mail_list(), msg_body)
smtpObj.quit()
def notify_mail(msg):
mail_obj = MIMEMultipart()
mail_obj['Subject'] = EMAIL_SUBJECT
mail_obj['From'] = private.mail_from_addr
mail_obj['To'] = listToStr(private.get_mail_list())
mail_obj.preamble = "This is a multi-part message in MIME format."
mail_obj.epilogue = ''
msg_txt = MIMEText(msg.replace("\n", "<br>"))
msg_txt.replace_header('Content-Type', 'text/html; charset="big5"')
mail_obj.attach(msg_txt)
msg_body = mail_obj.as_string()
smtpObj = smtplib.SMTP(private.mail_server_addr)
smtpObj.sendmail(private.mail_from_addr, private.get_mail_list(), msg_body)
smtpObj.quit()
def emailHtml(to, subject, message):
toList, to = processTo(to)
msg = MIMEMultipart()
msg['Subject'] = subject
msg['To'] = to
msg['From'] = fromEmail
msg['Date'] = formatdate()
msg.preamble = 'You are not using a MIME-aware reader\n'
msg.epilogue = ''
#add the main message
msg.attach(MIMEText(message))
rawEmail(toList, msg.as_string())
def emailHtml(to, subject, message):
toList, to = processTo(to)
msg = MIMEMultipart()
msg['Subject'] = subject
msg['To'] = to
msg['From'] = fromEmail
msg['Date'] = formatdate()
msg.preamble = 'You are not using a MIME-aware reader\n'
msg.epilogue = ''
#add the main message
msg.attach(MIMEText(message))
rawEmail(toList, msg.as_string())
def httprequest(self, postdata):
if not self.anubisURL.startswith("http://"):
raise "Invalid URL, only http:// URLs are allowed: url='%s'" % (self.anubisURL)
if not postdata:
raise "Invalid/No POST data supplied: postdata='%s'" % (postdata)
headers = {}
headers["Content-Type"] = "multipart/form-data"
message = MIMEMultipart(_subtype="form-data")
### notification element
part = MIMEText(None)
part.set_payload(postdata["notification"], "us-ascii")
part.add_header("Content-Disposition", "form-data", name="notification")
message.attach(part)
### email element
part = MIMEText(None)
part.set_payload(postdata["email"], "us-ascii")
part.add_header("Content-Disposition", "form-data", name="email")
message.attach(part)
### type element
part = MIMEText(None)
part.set_payload(postdata["analysisType"], "us-ascii")
part.add_header("Content-Disposition", "form-data", name="analysisType")
message.attach(part)
### file data element
part = MIMEBase('application', "octet-stream")
part.set_payload(postdata['executable']['content'])
### Add content-disposition header.
dispHeaders = postdata["executable"].get("headers", {})
part.add_header("Content-Disposition", "form-data", name="executable", filename=postdata["executable"]["filename"])
for dhName, dhValue in dispHeaders:
part.add_header(dhName, dhValue)
message.attach(part)
message.epilogue = ""
headerBlock, body = message.as_string().split("\n\n",1)
for hName, hValue in message.items():
headers[hName] = hValue
### Make the HTTP request and get the response.
### Precondition: 'url', 'method', 'headers', 'body' are all setup properly.
scheme, netloc, path, parameters, query, fragment = urlparse.urlparse(self.anubisURL)
if parameters or query or fragment:
raise "Unexpected URL: parameters=%r, query=%r, fragment=%r" % (parameters, query, fragment)
try:
conn = httplib.HTTPConnection(netloc)
conn.request("POST", path, body, headers)
response = conn.getresponse()
except socket.error, e:
response = ConnRes(404, e)
def notify_mail(project, tsp):
msg = "FACTORY ALERT!!! Project: %s, TSP: %s" % (project, tsp)
print msg
mail_obj = MIMEMultipart()
mail_obj['Subject'] = EMAIL_SUBJECT
mail_obj['From'] = EMAIL_FROM
mail_obj['To'] = listToStr(EMAIL_RECEIVERS)
mail_obj.preamble = "This is a multi-part message in MIME format."
mail_obj.epilogue = ''
msg_txt = MIMEText(msg)
msg_txt.replace_header('Content-Type', 'text/html; charset="big5"')
mail_obj.attach(msg_txt)
msg_body = mail_obj.as_string()
smtpObj = smtplib.SMTP('relay-b.pegatroncorp.com')
smtpObj.sendmail(EMAIL_FROM, EMAIL_RECEIVERS, msg_body)
smtpObj.quit()
def notify_mail(project, tsp):
msg = "FACTORY ALERT!!! Project: %s, TSP: %s" % (project, tsp)
print msg
mail_obj = MIMEMultipart()
mail_obj['Subject'] = EMAIL_SUBJECT
mail_obj['From'] = EMAIL_FROM
mail_obj['To'] = listToStr(EMAIL_RECEIVERS)
mail_obj.preamble = "This is a multi-part message in MIME format."
mail_obj.epilogue = ''
msg_txt = MIMEText(msg)
msg_txt.replace_header('Content-Type', 'text/html; charset="big5"')
mail_obj.attach(msg_txt)
msg_body = mail_obj.as_string()
smtpObj = smtplib.SMTP('relay-b.pegatroncorp.com')
smtpObj.sendmail(EMAIL_FROM, EMAIL_RECEIVERS, msg_body)
smtpObj.quit()
def send_mail(to, subject, text, attach):
###
if settings.DEBUG:
logger.debug(u"\n{}\n{}\n{}\n".format(to, subject, text))
return
###
try:
msg = MIMEMultipart('related')
organization = settings.MAIL_SENDER_ORGANIZATION
mailer = settings.MAIL_SENDER_MAILER
msg['Message-ID'] = msgid()
msg['Organization'] = make_header([(organization, 'UTF-8')])
msg['X-Mailer'] = make_header([(mailer, 'UTF-8')])
msg['From'] = make_header([(mailer, 'UTF-8'), ('<' + settings.MAIL_SENDER_SENDER + '>', 'us-ascii')])
msg['To'] = make_header([(to, 'us-ascii')])
msg['Subject'] = make_header([(subject, 'UTF-8')])
msg.preamble = "This is a multi-part message in MIME format."
msg.epilogue = "End of message"
# alternative part
msgAlternative = MIMEMultipart('alternative')
msg.attach(msgAlternative)
msgText = MIMEText(text, '', 'utf-8')
msgAlternative.attach(msgText)
# html part
to_attach = MIMEText(text.encode('utf-8'), 'html', 'utf-8')
msgAlternative.attach(to_attach)
if attach:
part = MIMEBase('application', 'octet-stream')
part.set_payload(open(attach, 'rb').read())
encode_base64(part)
part.add_header('Content-Disposition',
'attachment; filename="%s"' % os.path.basename(attach))
msg.attach(part)
mailServer = smtplib.SMTP(settings.MAIL_SENDER_SERVER, settings.MAIL_SENDER_PORT)
mailServer.ehlo()
mailServer.starttls()
mailServer.ehlo()
mailServer.login(settings.MAIL_SENDER_USER, settings.MAIL_SENDER_PASSWORD)
mailServer.sendmail(settings.MAIL_SENDER_SENDER, to, msg.as_string())
# Should be mailServer.quit(), but that crashes...
mailServer.close()
except Exception as e:
logger.error(u'\n\nMessage to "{}" with subject "{}" was not sended\nException message: "{}"\n'.format(to, subject, e.message))
return
def smtp_notify (event_type, description, content=None):
"""E-Mail Notification"""
# Create the container (outer) email message.
msg = MIMEMultipart('related')
msg['From'] = config.get('dbAlerter','smtp_from')
msg['To'] = config.get('dbAlerter','smtp_to')
msg.preamble = 'Notification for event - ' + event_type
# Guarantees the message ends in a newline
msg.epilogue = ''
# Encapsulate the plain and HTML versions of the message body in an
# 'alternative' part, so message agents can decide which they want to display.
msg_alt = MIMEMultipart('alternative')
msg.attach(msg_alt)
msg_text = MIMEText('This message was sent from the dbAlerter host (' + socket.gethostname() + ") to notify you that the following event has occured:\n\n" + event_type + ' - ' + description + "\n\nIf you are not the intended recipient of this notification please contact " + parseaddr(config.get('dbAlerter','smtp_from'))[1] + '.')
msg_alt.attach(msg_text)
if (content is None):
msg['Subject'] = event_type + ' on ' + socket.gethostname()
# We reference the image in the IMG SRC attribute by the ID we give it below
msg_text = MIMEText('<a href="http://www.wave2.org/w2wiki/dbalerter"><img src="cid:dbalerterlogo"></a><p>This message was sent from the <a href="http://www.wave2.org/w2wiki/dbalerter">dbAlerter</a> host (<b>' + socket.gethostname() + '</b>) to notify you that the following event has occured:</p><b><i>' + event_type + '</i></b> - ' + description + '<p>If you are not the intended recipient of this notification please contact <b><a href="mailto:' + parseaddr(config.get('dbAlerter','smtp_from'))[1] + '">' + parseaddr(config.get('dbAlerter','smtp_from'))[1] + '</a></b>.', 'html')
else:
msg['Subject'] = event_type + ' - ' + description
msg_text = MIMEText('<a href="http://www.wave2.org/w2wiki/dbalerter"><img src="cid:dbalerterlogo"></a><p>This message was sent from the <a href="http://www.wave2.org/w2wiki/dbalerter">dbAlerter</a> host (<b>' + socket.gethostname() + '</b>) with the following information:</p><pre>' + content + '</pre><p>If you are not the intended recipient of this notification please contact <b><a href="mailto:' + parseaddr(config.get('dbAlerter','smtp_from'))[1] + '">' + parseaddr(config.get('dbAlerter','smtp_from'))[1] + '</a></b>.', 'html')
msg_alt.attach(msg_text)
# This example assumes the image is in the current directory
fp = resource_stream(__name__, 'images/dbAlerter.jpg')
msg_image = MIMEImage(fp.read())
fp.close()
# Define the image's ID as referenced above
msg_image.add_header('Content-ID', '<dbalerterlogo>')
msg.attach(msg_image)
# Send the email via our own SMTP server.
s = smtplib.SMTP()
s.connect(config.get('dbAlerter', 'smtp_server'))
s.sendmail(config.get('dbAlerter', 'smtp_from'), config.get('dbAlerter', 'smtp_to'), msg.as_string())
s.close()
log_notify(event_type, description, 'Email')
def generate(self, fp):
msg = MIMEMultipart(_subtype='related')
msg['Subject'] = 'archived'
msg.epilogue = '' # Guarantees the message ends in a newline
for res in self.resource_list:
if '/' in res.ctype_actual:
maintype, subtype = res.ctype_actual.split('/',1)
else:
maintype, subtype = res.ctype_actual, ''
part = MIMENonMultipart(maintype, subtype)
part.set_payload(res.data)
part['content-location'] = res.uri
Encoders.encode_base64(part)
msg.attach(part)
# generate the MIME message
Generator(fp, False).flatten(msg)
def send_mail(email, body):
# Create the enclosing (outer) message
outer = MIMEMultipart()
outer['Subject']= 'Application error log'
outer['To']= email
#outer['CC']= email2
outer['From']= '*****@*****.**'
outer.preamble = '\n'
# To guarantee the message ends with a newline
outer.epilogue =''
# Note: we should handle calculating the charset
msg= MIMEText(body)
# Message body
outer.attach(msg)
text = outer.as_string()
MAIL = "/usr/sbin/sendmail"
p = os.popen("%s -t" % MAIL, 'w')
p.write(text)
p.close()
def send_email(filename):
msgsubject = 'Workout from Rowsberry Pi'
htmlmsgtext = """This is a workout recorded with Rowsberry Pi</br>
Yup. Yup. Yup.</br>"""
msgtext = htmlmsgtext.replace('<b>', '').replace('</b>', '').replace(
'<br>', "\r").replace('</br>', "\r").replace('<br/>',
"\r").replace('</a>', '')
msgtext = re.sub('<.*?>', '', msgtext)
msg = MIMEMultipart()
msg.preamble = 'This is a multi-part message in MIME format.\n'
msg.epilogue = ''
body = MIMEMultipart('alternative')
body.attach(MIMEText(msgtext))
body.attach(MIMEText(htmlmsgtext, 'html'))
msg.attach(body)
part = MIMEBase('application', "octet-stream")
part.set_payload(open(filename, "rb").read())
Encoders.encode_base64(part)
part.add_header('Content-Disposition',
'attachment; filename="%s"' % os.path.basename(filename))
msg.attach(part)
msg.add_header('From', email_fromaddress)
msg.add_header('To', email_recipients)
msg.add_header('Subject', msgsubject)
# The actual email sendy bits
server = smtplib.SMTP('%s:%s' % (email_host, email_port))
server.set_debuglevel(True)
if email_use_tls:
server.starttls()
server.login(email_host_user, email_host_password)
if not isinstance(email_recipients, list):
email_recipients = [email_recipients]
server.sendmail(msg['From'], email_recipients, msg.as_string())
server.quit() #bye bye
def prepare_email_message(self):
plain = self.plain
html = self.html
if not plain and not html:
return None
# We definitely want unicode at this point.
plain = utils.su(plain)
html = utils.su(html)
# We must choose the body charset manually. Note that the
# goal and effect of this loop is to determine the
# body_charset.
for body_charset in 'US-ASCII', utils.get_charset(), 'UTF-8':
try:
plain.encode(body_charset)
html.encode(body_charset)
except UnicodeEncodeError:
pass
else:
break
# Encoding should work now; let's replace errors just in case.
plain = plain.encode(body_charset, 'replace')
html = html.encode(body_charset, 'xmlcharrefreplace')
text_part = MIMEText(plain, 'plain', body_charset)
html_part = MIMEText(html, 'html', body_charset)
# No sense in sending plain text and html when we only have
# one of those:
if not plain:
return html_part
if not html:
return text_part
# Okay, we send both plain text and html
email_msg = MIMEMultipart('alternative')
email_msg.epilogue = ''
email_msg.attach(text_part)
email_msg.attach(html_part)
return email_msg
def prepare_email_message(self):
plain = self.plain
html = self.html
if not plain and not html:
return None
# We definitely want unicode at this point.
plain = utils.su(plain)
html = utils.su(html)
# We must choose the body charset manually. Note that the
# goal and effect of this loop is to determine the
# body_charset.
for body_charset in 'US-ASCII', utils.get_charset(), 'UTF-8':
try:
plain.encode(body_charset)
html.encode(body_charset)
except UnicodeEncodeError:
pass
else:
break
# Encoding should work now; let's replace errors just in case.
plain = plain.encode(body_charset, 'replace')
html = html.encode(body_charset, 'xmlcharrefreplace')
text_part = MIMEText(plain, 'plain', body_charset)
html_part = MIMEText(html, 'html', body_charset)
# No sense in sending plain text and html when we only have
# one of those:
if not plain:
return html_part
if not html:
return text_part
# Okay, we send both plain text and html
email_msg = MIMEMultipart('alternative')
email_msg.epilogue = ''
email_msg.attach(text_part)
email_msg.attach(html_part)
return email_msg
def mail_bulletin(context, formsemestre_id, I, pdfdata, filename):
"""Send bulletin by email to etud
If bul_mail_list_abs pref is true, put list of absences in mail body (text).
"""
etud = I['etud']
webmaster = context.get_preference('bul_mail_contact_addr', formsemestre_id)
dept = unescape_html(context.get_preference('DeptName',formsemestre_id))
copy_addr = context.get_preference('email_copy_bulletins',formsemestre_id)
intro_mail = context.get_preference('bul_intro_mail', formsemestre_id)
if intro_mail:
hea = intro_mail % { 'nomprenom' : etud['nomprenom'], 'dept':dept, 'webmaster':webmaster }
else:
hea = ''
if context.get_preference('bul_mail_list_abs'):
hea += '\n\n' + sco_abs_views.ListeAbsEtud(context,
etud['etudid'], with_evals=False, format='text')
msg = MIMEMultipart()
subj = Header( 'Relevé de notes de %s' % etud['nomprenom'], SCO_ENCODING )
recipients = [ etud['email'] ]
msg['Subject'] = subj
msg['From'] = context.get_preference('email_from_addr',formsemestre_id)
msg['To'] = ' ,'.join(recipients)
if copy_addr:
msg['Bcc'] = copy_addr.strip()
# Guarantees the message ends in a newline
msg.epilogue = ''
# Text
txt = MIMEText( hea, 'plain', SCO_ENCODING )
# log('hea:\n' + hea)
msg.attach(txt)
# Attach pdf
att = MIMEBase('application', 'pdf')
att.add_header('Content-Disposition', 'attachment', filename=filename)
att.set_payload( pdfdata )
Encoders.encode_base64(att)
msg.attach(att)
log('mail bulletin a %s' % msg['To'] )
context.sendEmail(msg)
def makemail(cfg, files, bodyfields):
ret = MIMEMultipart()
bodystr = ''.join(map(lambda (k,v) : '%s : %s\n' % (k,v), bodyfields.iteritems()))
ret.attach(MIMEText(bodystr))
seen = { }
for filename in files:
if seen.has_key(filename):
continue
seen[filename] = True
f = open(filename, 'r')
msg = MIMEText(f.read(), 'plain', 'iso8859-1')
f.close()
msg.add_header('Content-Disposition', 'attachment', filename=os.path.split(filename)[1])
ret.attach(msg)
ret['Subject'] = 'Automatically generated Marvin submission'
ret['From'] = cfg.get('user', 'email')
ret['To'] = cfg.get('kattis', 'email')
# Guarantees ending newline
ret.epilogue=''
return ret
def makemail(cfg, files, bodyfields):
ret = MIMEMultipart()
bodystr = ''.join(map(lambda (k,v) : '%s : %s\n' % (k,v), bodyfields.iteritems()))
ret.attach(MIMEText(bodystr))
seen = { }
for filename in files:
if seen.has_key(filename):
continue
seen[filename] = True
f = open(filename, 'r')
msg = MIMEText(f.read(), 'plain', 'iso8859-1')
f.close()
msg.add_header('Content-Disposition', 'attachment', filename=os.path.split(filename)[1])
ret.attach(msg)
ret['Subject'] = 'Automatically generated Marvin submission'
ret['From'] = cfg.get('user', 'email')
ret['To'] = cfg.get('kattis', 'email')
# Guarantees ending newline
ret.epilogue=''
return ret
def emailEntries(from_addr, to_addr, subj, smtp_host, entries):
"""
Given a from address, to address, a subject template, SMTP host,
and a list of entries, construct an email message via template for
each entry and send it off using the given header values.
"""
for entry in entries:
# Build a subject line for the current feed entry.
curr_subj = subj % entry
# Begin building the email message.
msg = MIMEMultipart()
msg['To'] = to_addr
msg['From'] = from_addr
msg['Subject'] = curr_subj
msg.preamble = "You would not see this in a MIME-aware mail reader.\n"
msg.epilogue = ""
# Generate a plain text alternative part.
plain_text = """
This email contains entries from your subscribed feeds in HTML.
"""
part = MIMEText(plain_text, "plain", UNICODE_ENC)
msg.attach(part)
# Generate the aggregate HTML page, read in the HTML data, attach it
# as another part of the email message.
out = []
out.append(FEED_HDR_TMPL % entry)
out.append(ENTRY_TMPL % entry)
html_text = PAGE_TMPL % "".join(out)
part = MIMEText(html_text, "html", UNICODE_ENC)
msg.attach(part)
# Finally, send the whole thing off as an email message.
print "Sending email '%s' to '%s'" % (curr_subj, to_addr)
s = smtplib.SMTP(smtp_host)
s.sendmail(from_addr, to_addr, msg.as_string())
s.close()
def emailEntries(from_addr, to_addr, subj, smtp_host, entries):
"""
Given a from address, to address, a subject template, SMTP host,
and a list of entries, construct an email message via template for
each entry and send it off using the given header values.
"""
for entry in entries:
# Build a subject line for the current feed entry.
curr_subj = subj % entry
# Begin building the email message.
msg = MIMEMultipart()
msg['To'] = to_addr
msg['From'] = from_addr
msg['Subject'] = curr_subj
msg.preamble = "You would not see this in a MIME-aware mail reader.\n"
msg.epilogue = ""
# Generate a plain text alternative part.
plain_text = """
This email contains entries from your subscribed feeds in HTML.
"""
part = MIMEText(plain_text, "plain", UNICODE_ENC)
msg.attach(part)
# Generate the aggregate HTML page, read in the HTML data, attach it
# as another part of the email message.
out = []
out.append(FEED_HDR_TMPL % entry)
out.append(ENTRY_TMPL % entry)
html_text = PAGE_TMPL % "".join(out)
part = MIMEText(html_text, "html", UNICODE_ENC)
msg.attach(part)
# Finally, send the whole thing off as an email message.
print "Sending email '%s' to '%s'" % (curr_subj, to_addr)
s = smtplib.SMTP(smtp_host)
s.sendmail(from_addr, to_addr, msg.as_string())
s.close()
def send_email(addresses, host, port, from_address, subject, html_email,
plain_email, avatars, tweet_images):
password = raw_input('Password: '******'related')
msgRoot['Subject'] = subject
msgRoot['From'] = from_address
msgRoot['To'] = ', '.join(addresses)
msgRoot.epilogue = ''
msgAlternative = MIMEMultipart('alternative')
msgRoot.attach(msgAlternative)
msgText = MIMEText(plain_email.encode('utf-8'))
msgAlternative.attach(msgText)
msgText = MIMEText(html_email.encode('utf-8'), 'html')
msgAlternative.attach(msgText)
for avatar in avatars:
with open("{0}_av".format(avatar), 'rb') as fp:
msgImage = MIMEImage(fp.read())
msgImage.add_header('Content-ID', '<{0}_av>'.format(avatar))
msgRoot.attach(msgImage)
for tweet_image in tweet_images:
with open(tweet_image, 'rb') as fp:
msgImage = MIMEImage(fp.read())
msgImage.add_header('Content-ID', '<{0}>'.format(tweet_image))
msgRoot.attach(msgImage)
with open("plone-logo.png", 'rb') as fp:
msgImage = MIMEImage(fp.read())
msgImage.add_header('Content-ID', '<plone-logo.png>')
msgRoot.attach(msgImage)
session = smtplib.SMTP(host, port)
session.starttls()
session.login(from_address, password)
session.sendmail(from_address, addresses, msgRoot.as_string())
session.quit()
def add_attachment(self, path):
#Create a multipart message and each attachment gets a part
if not self.email.is_multipart():
newemail = MIMEMultipart()
newemail['Subject'] = self.email['Subject']
newemail['To'] = self.email['To']
newemail['From'] = self.email['From']
newemail.preamble = 'There are attachments\n'
newemail.epilogue = ''
self.email = newemail
f = File.File(path)
filename = f.get_filename()
mt = f.get_mimetype()
maintype, subtype = mt.split('/', 1)
if maintype == 'text':
fp = open(path)
#We should handle calculating the charset
msg = MIMEText(fp.read(), _subtype=subtype)
fp.close()
elif maintype == 'image':
fp = open(path, 'rb')
msg = MIMEImage(fp.read(), _subtype=subtype)
fp.close()
elif maintype == 'audio':
fp = open(path, 'rb')
msg = MIMEAudio(fp.read(), _subtype=subtype)
fp.close()
else:
fp = open(path, 'rb')
msg = MIMEBase('application', 'octet-stream')
msg.set_payload(fp.read())
fp.close()
# Encode the payload using Base64
Encoders.encode_base64(msg)
# Set the filename parameter
msg.add_header('Content-Disposition', 'attachment', filename=filename)
self.email.attach(msg)
self.attachments.append(path)
def send_mail(self, fromaddr, toaddrs, subject, contents, attachments=[]):
import smtplib
import mimetypes
from email import Encoders
from email.Message import Message
from email.MIMEBase import MIMEBase
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
# FIXME: assume that return value is set on all errors..
# FIXME: raise exceptions on send errors
msg = MIMEMultipart()
msg['Subject'] = subject
msg['From'] = fromaddr
msg['To'] = ', '.join(toaddrs)
msg.preamble = contents
msg.epilogue = ''
att = MIMEText(contents, 'plain')
msg.attach(att)
for subtype, filename in attachments:
f = open(filename, 'rb')
att = MIMEBase('application', subtype)
att.set_payload(f.read())
Encoders.encode_base64(att)
att.add_header('Content-Disposition',
'attachment',
filename=os.path.basename(filename))
f.close()
msg.attach(att)
s = smtplib.SMTP(SMTP_SERVER)
s.sendmail(fromaddr, toaddrs, msg.as_string())
def send_report(txtreport, htmlreport):
if options.emails is None:
return
print "sending email to", options.emails
try:
sender = '*****@*****.**'
recipients = options.emails
subject = ' system-test results'
message = MIMEMultipart('alternative')
message['To'] = ', '.join(recipients)
message['From'] = sender
message['Subject'] = subject
# message.preamble = subject
message.epilogue = ''
p1 = MIMEText(txtreport, 'plain')
p2 = MIMEText(htmlreport, 'html')
message.attach(p1)
message.attach(p2)
session = smtplib.SMTP('localhost')
session.sendmail(sender, recipients, message.as_string())
session.quit()
except smtplib.SMTPException, e:
print "Couldn't send report. %s" % e
def odf2mht(self, odtfile):
tmpfile = saveodtfile(odtfile)
self.REQUEST.RESPONSE.setHeader('Content-Type', 'message/rfc822')
msg = MIMEMultipart('related', type="text/html")
msg.preamble = 'This is a multi-part message in MIME format.'
msg.epilogue = ''
result = odf2xhtml(tmpfile).encode('us-ascii', 'xmlcharrefreplace')
htmlpart = MIMEText(result, 'html', 'us-ascii')
htmlpart['Content-Location'] = 'index.html'
msg.attach(htmlpart)
z = zipfile.ZipFile(tmpfile)
for file in z.namelist():
if file[0:9] == 'Pictures/':
suffix = file[file.rfind(".") + 1:]
main, sub = suffices.get(suffix, ('application', 'octet-stream'))
img = MIMENonMultipart(main, sub)
img.set_payload(z.read(file))
img['Content-Location'] = "" + file
Encoders.encode_base64(img)
msg.attach(img)
z.close()
unlink(tmpfile)
return msg.as_string()
def main():
if not len(sys.argv) == 2:
print >> sys.stderr, "Usage: ./audreytoo.py /path/to/images/"
sys.exit(1)
image_directory = sys.argv[1]
if not os.path.isdir(image_directory):
print >> sys.stderr, "%s is not readable. Aborting." % (
image_directory)
sys.exit(1)
today = date.today()
# Build Message
outer = MIMEMultipart()
outer['Subject'] = 'Picture of the week: %s Edition' % today.strftime(
"%B %d")
outer['To'] = ", ".join(TO)
outer['From'] = FROM
outer.preamble = 'Picture of the week: %s Edition\n' % today.strftime(
"%B %d")
# To guarantee the message ends with a newline. I stole this from somewhere on the net.
outer.epilogue = ''
highpriority = []
lowpriority = []
for filename in os.listdir(image_directory):
if not os.path.isfile(os.path.join(
image_directory, filename)) or os.path.splitext(
filename)[1].lower() not in VALID_FILES:
continue
# If the file starts with next-, we'll send that right away. note that
# next-01 is a higher priority than next-02, etc.
if filename.startswith('next-'):
highpriority.append(filename)
else:
lowpriority.append(filename)
if not len(highpriority) and not len(lowpriority):
mail_admin("You're all out of pictures. :(")
sys.exit(1)
if len(highpriority):
highpriority.sort()
filename = highpriority.pop(0)
else:
filename = random.choice(lowpriority)
try:
path = os.path.join(image_directory, filename)
fp = open(path, 'rb')
msg = MIMEImage(fp.read())
fp.close()
# Set the filename parameter
msg.add_header('Content-Disposition', 'attachment', filename=filename)
outer.attach(msg)
# Now send the message
s = smtplib.SMTP(SMTP_SERVER)
s.login(SMTP_USER, SMTP_PASS)
s.sendmail(FROM, TO, outer.as_string())
s.close()
os.remove(path)
total_remaining = len(highpriority) + len(lowpriority) - 1
if total_remaining < 10:
# Total number of pictures is less than 10, give ADMIN a heads up
mail_admin("Only %s pictures left in the pool" % (total_remaining),
"Need more pictures!")
except:
mail_admin("Something is broken!",
"Output:\n\n%s" % (sys.exc_info()[0]))
def httprequest(url, postdata={}, headers=None, ssl=False):
"""A urllib.urlopen() replacement for http://... that gets the
content-type right for multipart POST requests.
"url" is the http URL to open.
"postdata" is a dictionary describing data to post. If the dict is
empty (the default) a GET request is made, otherwise a POST
request is made. Each postdata item maps a string name to
either:
- a string value; or
- a file part specification of the form:
{"filename": <filename>, # file to load content from
"content": <content>, # (optional) file content
"headers": <headers>} # (optional) headers
<filename> is used to load the content (can be overridden by
<content>) and as the filename to report in the request.
<headers> is a dictionary of headers to use for the part.
Note: currently the file part content but be US-ASCII text.
"headers" is an optional dictionary of headers to send with the
request. Note that the "Content-Type" and "Content-Length"
headers are automatically determined.
The current urllib.urlopen() *always* uses:
Content-Type: application/x-www-form-urlencoded
for POST requests. This is incorrect if the postdata includes a file
to upload. If a file is to be posted the post data is:
Content-Type: multipart/form-data
This returns the response content if the request was successfull
(HTTP code 200). Otherwise an IOError is raised.
For example, this invocation:
url = 'http://www.perl.org/survey.cgi'
postdata = {
"name": "Gisle Aas",
"email": "gisle at aas.no",
"gender": "M",
"born": "1964",
"init": {"filename": "~/.profile"},
}
Inspiration: Perl's HTTP::Request module.
http://aspn.activestate.com/ASPN/Reference/Products/ActivePerl/site/lib/HTTP/Request/Common.html
"""
if not url.startswith("http://"):
raise "Invalid URL, only http:// URLs are allow: url='%s'" % url
if not headers:
headers = {}
if not postdata:
method = "GET"
body = None
else:
method = "POST"
# Determine if require a multipart content-type: 'contentType'.
for part in postdata.values():
if isinstance(part, dict):
contentType = "multipart/form-data"
break
else:
contentType = "application/x-www-form-urlencoded"
headers["Content-Type"] = contentType
# Encode the post data: 'body'.
if contentType == "application/x-www-form-urlencoded":
body = urllib.urlencode(postdata)
elif contentType == "multipart/form-data":
message = MIMEMultipart(_subtype="form-data")
for name, value in postdata.items():
if isinstance(value, dict):
# Get content.
if "content" in value:
content = value["content"]
else:
fp = open(value["filename"], "rb")
content = fp.read()
part = MIMEBase('application', "octet-stream")
part.set_payload(content)
# Encoders.encode_base64(part)
# Add content-disposition header.
dispHeaders = value.get("headers", {})
if "Content-Disposition" not in dispHeaders:
#XXX Should be a case-INsensitive check.
part.add_header("Content-Disposition",
"form-data",
name=name,
filename=value["filename"])
for dhName, dhValue in dispHeaders:
part.add_header(dhName, dhValue)
else:
# Do not use ctor to set payload to avoid adding a
# trailing newline.
part = MIMEText(None)
part.set_payload(value, "us-ascii")
part.add_header("Content-Disposition",
"form-data",
name=name)
message.attach(part)
message.epilogue = "" # Make sure body ends with a newline.
# Split off the headers block from the .as_string() to get
# just the message content. Also add the multipart Message's
# headers (mainly to get the Content-Type header _with_ the
# boundary attribute).
headerBlock, body = message.as_string().split("\n\n", 1)
for hName, hValue in message.items():
headers[hName] = hValue
#print "XXX ~~~~~~~~~~~~ multi-part body ~~~~~~~~~~~~~~~~~~~"
#import sys
#sys.stdout.write(body)
#print "XXX ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
else:
raise "Invalid content-type: '%s'" % contentType
# Make the HTTP request and get the response.
# Precondition: 'url', 'method', 'headers', 'body' are all setup properly.
scheme, netloc, path, parameters, query, fragment = urlparse.urlparse(url)
if parameters or query or fragment:
raise "Unexpected URL form: parameters, query or fragment parts "\
"are not allowed: parameters=%r, query=%r, fragment=%r"\
% (parameters, query, fragment)
if ssl:
conn = httplib.HTTPSConnection(netloc)
else:
conn = httplib.HTTPConnection(netloc)
conn.request(method, path, body, headers)
response = conn.getresponse()
return response
def create_email_message(fromaddr,
toaddrs,
ccaddrs,
subject,
priority,
include_project=False,
stack_trace="",
comments=""):
# format a message suitable to be sent to the Roundup bug tracker
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from email.MIMEBase import MIMEBase
message = MIMEMultipart()
message['Subject'] = "%s [priority=%s]" % (subject, priority)
message['To'] = ', '.join(toaddrs)
message['Cc'] = ', '.join(ccaddrs)
message['From'] = fromaddr
message.preamble = 'You will not see this in a MIME-aware mail reader.\n'
message.epilogue = ' ' # To guarantee the message ends with a newline
# First section is simple ASCII data ...
m = []
m.append("Bug Report")
m.append("==============================")
m.append("")
if len(comments) > 0:
m.append("Comments:")
m.append("========")
m.append(comments)
m.append("")
if len(stack_trace) > 0:
m.append("Stack Trace:")
m.append("===========")
m.append(stack_trace)
m.append("")
msg = MIMEText('\n'.join(m))
message.attach(msg)
# Include the log file ...
if True:
try:
log = os.path.join(get_home_directory(), 'envisage.log')
f = open(log, 'r')
entries = f.readlines()
f.close()
ctype = 'application/octet-stream'
maintype, subtype = ctype.split('/', 1)
msg = MIMEBase(maintype, subtype)
msg = MIMEText(''.join(entries))
msg.add_header(
'Content-Disposition', 'attachment', filename='logfile.txt')
message.attach(msg)
except:
logger.exception('Failed to include log file with message')
# Include the environment variables ...
if True:
"""
Transmit the user's environment settings as well. Main purpose is to
work out the user name to help with following up on bug reports and
in future we should probably send less data.
"""
try:
entries = []
for key, value in os.environ.items():
entries.append('%30s : %s\n' % (key, value))
ctype = 'application/octet-stream'
maintype, subtype = ctype.split('/', 1)
msg = MIMEBase(maintype, subtype)
msg = MIMEText(''.join(entries))
msg.add_header(
'Content-Disposition',
'attachment',
filename='environment.txt')
message.attach(msg)
except:
logger.exception(
'Failed to include environment variables with message')
# FIXME: no project plugins exist for Envisage 3, yet, and this isn't the right
# way to do it, either. See the docstring of attachments.py.
# # Attach the project if requested ...
# if include_project:
# from attachments import Attachments
# try:
# attachments = Attachments(message)
# attachments.package_any_relevant_files()
# except:
# logger.exception('Failed to include workspace files with message')
return message
def mandar_mail(pm_servidor_correo,
pm_login_usuario,
pm_login_password,
pm_emisor_nombre,
pm_emisor_correo,
pm_receptor_nombre,
pm_receptor_correo,
pm_asunto,
pm_archivo_texto,
pm_archivo_html,
pm_adjuntos=[],
pm_acuse_recibo=False,
pm_imagenes_embebidas=[]):
"""
Rutina para enviar correo electrónico, permitiendo enviar el
mensaje alternativa/conjuntamente en modo texto y html, así como
con archivos adjuntos, imágenes embebidas y pudiendo solicitar
confirmación de lectura.
"""
assert type(pm_adjuntos) == list
assert type(pm_imagenes_embebidas) == list
#Inicializamos el mensaje a enviar y vamos añadiendo partes
msgRaiz = MIMEMultipart('related')
msgRaiz['From'] = pm_emisor_nombre + ' <' + pm_emisor_correo + '>'
msgRaiz['To'] = pm_receptor_correo
msgRaiz['Subject'] = pm_asunto
msgRaiz['Date'] = formatdate(localtime=True)
msgRaiz.preamble = '' #De momento, no lo uso
msgRaiz.epilogue = '' #De momento, no lo uso
if pm_acuse_recibo:
msgRaiz['Disposition-Notification-To'] = pm_emisor_correo
#Se encapsulan las versiones de texto plano y html del cuerpo
#del mensaje en una parte 'alternative' para que el cliente de
#correo decida qué parte mostrar
msgAlternativo = MIMEMultipart('alternative')
msgRaiz.attach(msgAlternativo)
#Abrimos mensaje de texto alternativo y lo añadimos
# fp = open(pm_archivo_texto, 'rb')
msgTexto = MIMEText(pm_archivo_texto, 'plain')
# msgTexto = MIMEText(fp.read(), 'plain')
msgAlternativo.attach(msgTexto)
# fp.close()
#Abrimos mensaje html alternativo y lo añadimos
# fp = open(pm_archivo_html, 'rb')
msgHtml = MIMEText(pm_archivo_html, 'html')
# msgHtml = MIMEText(fp.read(), 'html')
msgAlternativo.attach(msgHtml)
# fp.close()
#Añadimos las imágenes embebidas, si las hay
for imagen in pm_imagenes_embebidas:
#Cargar imagen
archivo_imagen = open(imagen, 'rb')
msgImage = MIMEImage(archivo_imagen.read())
archivo_imagen.close()
#Hemos de adjuntar la imagen en el content-id.
#En el archivo html se debe hacer referencia al content-id
#como fuente en el source de la imagen, por ejemplo:
#<img src="cid:/nombre/de_la_ruta_entera/imagen.jpg">
msgImage.add_header('Content-ID', '<' + imagen + '>')
msgRaiz.attach(msgImage)
#Añadimos los ficheros adjuntos a mandar , si los hay
for file in pm_adjuntos:
adjunto = MIMEBase('application', "octet-stream")
adjunto.set_payload(open(file, "rb").read())
Encoders.encode_base64(adjunto)
adjunto.add_header(
'Content-Disposition',
'attachment; filename = "%s"' % os.path.basename(file))
msgRaiz.attach(adjunto)
#Conectamos con el servidor de correo y mandamos el mensaje
servidor = smtplib.SMTP(pm_servidor_correo)
#servidor.set_debuglevel(1)
servidor.starttls()
servidor.ehlo()
servidor.login(pm_login_usuario, pm_login_password)
try:
servidor.sendmail(pm_emisor_correo, pm_receptor_correo,
msgRaiz.as_string())
servidor.quit()
resultado = True
except:
resultado = False
return (resultado)
