def discussion_notify(comment_on_object, variables = {}):
portal = comment_on_object.portal_url.getPortalObject()
send_from_address = portal.portal_properties.email_from_address
send_from_name = portal.portal_properties.email_from_name
host = portal.plone_utils.getMailHost()
encoding = portal.plone_utils.getSiteEncoding()
envelope_from = send_from_address
mt = portal.portal_membership
if IDiscussionResponse.providedBy(comment_on_object):
owner = comment_on_object.Creator()
if owner:
member = mt.getMemberById(owner)
if member:
send_to_address = member.getProperty('email')
if send_to_address:
message_body = portal.discussion_reply_notify_template(portal, comment_on_object=comment_on_object, send_from_address=send_from_address, send_from_name=send_from_name, send_to_address=send_to_address, **variables)
subject = "New comment on " + comment_on_object.title_or_id()
message = message_from_string(message_body.encode(encoding))
message.set_charset(encoding)
message['From'] = Header(envelope_from)
if PLONE4:
host.send(message, send_to_address, envelope_from, subject=subject, charset=encoding, msg_type='text/plain')
else:
host.secureSend(message_body, send_to_address, envelope_from, subject=subject, subtype='plain', charset=encoding, debug=False, From=envelope_from)
parents = comment_on_object.parentsInThread()
if not parents:
return
comment_on_object = parents[0]
owner = comment_on_object.Creator()
if owner:
member = mt.getMemberById(owner)
if member:
send_to_address = member.getProperty('email')
if send_to_address:
message_body = portal.discussion_notify_template(portal, comment_on_object=comment_on_object, send_from_address=send_from_address, send_from_name=send_from_name, send_to_address=send_to_address, **variables)
subject = "New comment on " + comment_on_object.title_or_id()
message = message_from_string(message_body.encode(encoding))
message.set_charset(encoding)
message['From'] = Header(envelope_from)
if PLONE4:
host.send(message, send_to_address, envelope_from, subject=subject, charset=encoding, msg_type='text/plain')
else:
host.secureSend(message_body, send_to_address, envelope_from, subject=subject, subtype='plain', charset=encoding, debug=False, From=envelope_from)
def encode_if_needed(text, charset, encoding='q'):
needed = False
if notascii.search(text):
# Fall back on something vaguely sensible if there are high chars
# and the encoding is us-ascii
if charset == 'us-ascii':
charset = 'iso-8859-15'
return Header(text, charset)
else:
return Header(text, 'us-ascii')
def send_email(sender, recipient, subject, body):
"""Send an email.
All arguments should be Unicode strings (plain ASCII works as well).
Only the real name part of sender and recipient addresses may contain
non-ASCII characters.
The email will be properly MIME encoded and delivered though SMTP to
localhost port 25. This is easy to change if you want something different.
The charset of the email will be the first one out of US-ASCII, ISO-8859-1
and UTF-8 that can represent all the characters occurring in the email.
"""
print 'send_email', recipient, subject
# Header class is smart enough to try US-ASCII, then the charset we
# provide, then fall back to UTF-8.
header_charset = 'ISO-8859-1'
# We must choose the body charset manually
for body_charset in 'US-ASCII', 'ISO-8859-1', 'UTF-8':
try:
body.encode(body_charset)
except UnicodeError:
pass
else:
break
# Split real name (which is optional) and email address parts
sender_name, sender_addr = parseaddr(sender)
recipient_name, recipient_addr = parseaddr(recipient)
# We must always pass Unicode strings to Header, otherwise it will
# use RFC 2047 encoding even on plain ASCII strings.
sender_name = str(Header(unicode(sender_name), header_charset))
recipient_name = str(Header(unicode(recipient_name), header_charset))
# Make sure email addresses do not contain non-ASCII characters
sender_addr = sender_addr.encode('ascii')
recipient_addr = recipient_addr.encode('ascii')
# Create the message ('plain' stands for Content-Type: text/plain)
msg = MIMEText(body.encode(body_charset), 'plain', body_charset)
msg['From'] = formataddr((sender_name, sender_addr))
msg['To'] = formataddr((recipient_name, recipient_addr))
msg['Subject'] = Header(unicode(subject), header_charset)
# Send the message via SMTP to localhost:25
smtp = SMTP("127.0.0.1")
smtp.ehlo()
smtp.sendmail('*****@*****.**', recipient, msg.as_string())
smtp.quit()
def send_button_handler(self, action):
""" create and Send the Email """
data, errors = self.extractData()
if len(errors) == 0:
mh = getToolByName(self.context, 'MailHost')
contact_info = getUtility(IContactInformation)
userid = self.context.portal_membership.getAuthenticatedMember()
userid = userid.getId()
intern_receiver = []
for receiver in data.get('intern_receiver', []):
# cut away the username
intern_receiver.append(receiver.split(':')[0])
extern_receiver = data.get('extern_receiver') or []
addresses = intern_receiver + extern_receiver
# create the mail
msg = self.create_mail(data.get('message'),
data.get('documents'),
only_links=data.get('documents_as_links'))
msg['Subject'] = Header(data.get('subject'), CHARSET)
sender_address = contact_info.get_user(userid).email
if not sender_address:
portal = self.context.portal_url.getPortalObject()
sender_address = portal.email_from_address
mail_from = '%s <%s>' % (contact_info.describe(userid).encode(
CHARSET), sender_address.encode(CHARSET))
msg['From'] = Header(mail_from, CHARSET)
header_to = Header(','.join(addresses), CHARSET)
msg['To'] = header_to
# send it
mh.send(msg, mfrom=mail_from, mto=','.join(addresses))
# let the user know that the mail was sent
info = _(u'info_mails_sent', 'Mails sent')
notify(
DocumentSent(self.context, userid, header_to,
data.get('subject'), data.get('message'),
data.get('documents')))
IStatusMessage(self.request).addStatusMessage(info, type='info')
# and redirect to default view / tab
return self.request.RESPONSE.redirect(
get_containg_document_tab_url(data.get('documents')[0]))
def get_new_mail(exes):
max_id = msg.last_msg()
#print 'checking mail from id %d' % (max_id + 1)
M = imaplib.IMAP4_SSL(config.IMAP_SERVER, config.IMAP_PORT)
M.login(config.EMAIL_USER, config.EMAIL_PASS)
M.select(config.EMAIL_BOX)
typ, data = M.search(None, 'ALL')
#print data[0]
for num in data[0].split():
n = int(num)
if n > max_id:
typ, data = M.fetch(num, '(RFC822)')
for response_part in data:
if isinstance(response_part, tuple):
m = msg(n, response_part[1])
m.insert()
res = None
if exes.has_key(m.subject):
res = exes[m.subject].process(m)
if not res:
res = {'body': 'command not found'}
print 'processing message %d from %s command not found' % (
m.id, m.frm)
if res:
server = smtplib.SMTP()
server.connect(config.SMTP_SERVER, config.SMTP_PORT)
server.ehlo()
server.starttls()
server.login(config.EMAIL_USER, config.EMAIL_PASS)
sm = MIMEMultipart()
sm['Subject'] = Header(u'Re: ' + m.title,
'gb2312').encode()
sm['To'] = Header(m.frm, 'gb2312').encode()
sm['From'] = 'Q <*****@*****.**>'
sm['cc'] = '*****@*****.**'
sm.attach(MIMEText(res['body'].encode('gbk')))
if res.has_key('file') and res['file']:
sm.attach(MIMEImage(file(res['file']).read()))
server.sendmail('Q <*****@*****.**>',
m.frm.encode('gbk'), sm.as_string())
server.quit()
M.close()
M.logout()
def sendmail(self, toaddr, subject, body, cc=[], bcc=[]):
if not self.server:
self.connect()
logging.info('Send mail to %s' % toaddr)
for body_charset in 'US-ASCII', 'ISO-8859-1', 'UTF-8':
try:
body.encode(body_charset)
except UnicodeError:
pass
else:
break
from_name, from_addr = parseaddr(self.fromaddr)
to_name, to_addr = parseaddr(toaddr)
from_name = str(Header(unicode(from_name), self.header_charset))
to_name = str(Header(unicode(to_name), self.header_charset))
from_addr = from_addr.encode('ascii')
to_addr = to_addr.encode('ascii')
if from_addr == to_addr:
logging.info('Send mail to myself is not allowed now.')
return
email_format = 'html' if self.HTML else 'plain'
msg = MIMEText(body.encode(body_charset), email_format, body_charset)
msg['From'] = formataddr((from_name, from_addr))
msg['To'] = formataddr((to_name, to_addr))
if cc:
msg['CC'] = ', '.join([self._formataddr(x) for x in cc])
if bcc:
msg['BCC'] = ', '.join([self._formataddr(x) for x in bcc])
msg['Subject'] = Header(unicode(subject), self.header_charset)
msg['date'] = time.strftime('%a, %d %b %Y %H:%M:%S %z')
try:
self.server.sendmail(self.fromaddr, [toaddr] + cc + bcc,
msg.as_string())
except Exception, e:
logging.error('Send mail from %s:%s to %s failed: %s' %
(self.host, self.port, toaddr, e))
def format_header(self, key, name, email=None):
from email.Header import Header #@UnresolvedImport
maxlength = MAXHEADERLEN-(len(key)+2)
# Do not sent ridiculous short headers
if maxlength < 10:
raise AssertionError, "Header length is too short"
try:
tmp = name.encode('utf-8') if isinstance(name, unicode) else name
header = Header(tmp, 'utf-8', maxlinelen=maxlength)
except UnicodeEncodeError:
header = Header(name, self._charset, maxlinelen=maxlength)
if not email:
return header
else:
return '"%s" <%s>' % (header, email)
def format_header(self, key, name, email=None):
from email.Header import Header
maxlength = MAXHEADERLEN - (len(key) + 2)
# Do not sent ridiculous short headers
if maxlength < 10:
raise TracError(_("Header length is too short"))
try:
tmp = name.encode('ascii')
header = Header(tmp, 'ascii', maxlinelen=maxlength)
except UnicodeEncodeError:
header = Header(name, self._charset, maxlinelen=maxlength)
if not email:
return header
else:
return '"%s" <%s>' % (header, email)
def sendMail(db,
recipients,
title,
message_in,
sender=None,
cc=None,
bcc=None,
immediate=False,
msg_format='html'):
"""Send an email"""
host = getToolByName(db, 'MailHost')
mtype = 'html'
if msg_format == 'html':
message = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"' \
' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\n'
message = message + "<html>"
message = message + message_in
message = message + "</html>"
elif msg_format == 'text':
mtype = 'plain'
message = message_in
else:
raise Exception('Invalid message format')
if not sender:
sender = db.getCurrentMember().getProperty("email")
mail_message = message_from_string(asUnicode(message).encode('utf-8'))
mail_message.set_charset('utf-8')
mail_message.set_type("text/%s" % mtype)
if cc:
mail_message['CC'] = Header(cc)
if bcc:
mail_message['BCC'] = Header(bcc)
if HAS_PLONE40:
host.send(mail_message,
recipients,
sender,
asUnicode(title).encode('utf-8'),
msg_type='text/%s' % mtype,
immediate=immediate)
else:
host.secureSend(message,
recipients,
sender,
subject=title,
subtype=mtype,
charset='utf-8')
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 SendMail(toMail, subject, content):
print 'SendMail', toMail, subject, content
smtpHost = 'smtp.exmail.qq.com'
# smtpPort = '25'
sslPort = '465'
fromMail = '*****@*****.**'
# toMail = '*****@*****.**'
username = '******'
password = '******'
# subject = u'[Notice]hello'
# body = u'hello,this is a mail from '
encoding = 'utf-8'
mail = MIMEText(content.encode(encoding), 'plain', encoding)
mail['Subject'] = Header(subject, encoding)
mail['From'] = fromMail
mail['To'] = toMail
mail['Date'] = formatdate()
try:
smtp = smtplib.SMTP_SSL(smtpHost, sslPort)
smtp.ehlo()
smtp.login(username, password)
smtp.sendmail(fromMail, toMail, mail.as_string())
smtp.close()
print 'SEND Mail OK'
except Exception:
print 'ERROR:unable to send mail'
def send_email():
mail_username = EMAIL_USER_NAME
mail_password = EMAIL_PASSWORD
from_addr = FROM_ADDRESS
to_addrs = TO_ADDRESS
#html_content
send_html = get_html()
# HOST & PORT
HOST = EMAIL_HOST
PORT = HOST_PORT
# Create SMTP Object
smtp = smtplib.SMTP()
smtp.connect(HOST,PORT)
smtp.login(mail_username,mail_password)
msgRoot = MIMEMultipart('related')
msg1 = MIMEText(send_html,'html','utf-8')
with open(IMAGE_PATH,'rb') as f:
msg2 = MIMEImage(f.read())
msg2['Content-Disposition'] = 'inline;filename="image.jpg"'
msg2.add_header('Content-ID', '<image1>')
with open(TABLE_SAVE_PATH,'rb') as f:
msg3 = MIMEText(f.read(),'base64','gb2312')
msg3["Content-Type"] = 'application'
msg3["Content-Disposition"] = 'attachment;filename="爬虫库资源详情.xlsx"'
msgRoot.attach(msg1)
msgRoot.attach(msg2)
msgRoot.attach(msg3)
msgRoot['From'] = from_addr
msgRoot['To'] = ';'.join(to_addrs)
msgRoot['Subject']= Header('爬虫库状态通知邮件(' + str(date.today()) + ')','utf-8')
smtp.sendmail(from_addr,to_addrs,msgRoot.as_string())
smtp.quit()
def send_txt(self, filename):
# 这里发送附件尤其要注意字符编码，当时调试了挺久的，因为收到的文件总是乱码
self.smtp = smtplib.SMTP()
self.smtp.connect(self.server)
self.smtp.login(self.username, self.password)
self.msg = MIMEMultipart()
self.msg['to'] = self.to_mail
self.msg['from'] = self.from_mail
self.msg['Subject'] = "Convert"
self.filename = filename + ".txt"
self.msg['Date'] = Utils.formatdate(localtime=1)
content = open(self.filename.decode('utf-8'), 'rb').read()
# print content
self.att = MIMEText(content, 'base64', 'utf-8')
self.att['Content-Type'] = 'application/octet-stream'
# self.att["Content-Disposition"] = "attachment;filename=\"%s\"" %(self.filename.encode('gb2312'))
self.att[
"Content-Disposition"] = "attachment;filename=\"%s\"" % Header(
self.filename, 'gb2312')
# print self.att["Content-Disposition"]
self.msg.attach(self.att)
self.smtp.sendmail(self.msg['from'], self.msg['to'],
self.msg.as_string())
self.smtp.quit()
def sendMail(message, encoding='utf-8'):
msg = MIMEMultipart('alternative')
msg['Subject'] = Header(MAIL_TITLE.encode(encoding), encoding)
msg['From'] = SENDER
msg['To'] = SENDER
text = message
msg.attach(MIMEText(text.encode(encoding), 'html', encoding))
# Attach file if specified
if FILE_JOINED:
part = MIMEBase('application', 'octet-stream')
part.set_payload(open(FILE_JOINED, 'rb').read())
Encoders.encode_base64(part)
part.add_header(
'Content-Disposition',
'attachment; filename="%s"' % FILE_JOINED.split("/")[-1])
msg.attach(part)
s = smtplib.SMTP(HOST, PORT)
s.starttls()
s.login(SENDER, SENDER_PASSWORD)
try:
s.sendmail(SENDER, SENDER, msg.as_string())
except:
s.quit()
return '%s Failed to send mail' % (SENDER)
s.quit()
return '%s / mail sent !' % (SENDER)
def get_subject(self, fields, request, context):
"""Return subject
"""
# get subject header
nosubject = u'(no subject)' # TODO: translate
subject = None
if hasattr(self, 'subjectOverride') and self.subjectOverride:
# subject has a TALES override
subject = get_expression(context,
self.subjectOverride,
fields=fields).strip()
if not subject:
subject = getattr(self, 'msg_subject', nosubject)
subjectField = fields.get(self.subject_field, None)
if subjectField is not None:
subject = subjectField
else:
# we only do subject expansion if there's no field chosen
subject = dollar_replacer(subject, fields)
if isinstance(subject, basestring):
subject = safe_unicode(subject)
elif subject and isinstance(subject, (set, tuple, list)):
subject = ', '.join([safe_unicode(s) for s in subject])
else:
subject = nosubject
# transform subject into mail header encoded string
email_charset = 'utf-8'
msgSubject = self.secure_header_line(subject).encode(
email_charset, 'replace')
msgSubject = str(Header(msgSubject, email_charset))
return msgSubject
def encode_header(header_text):
"""Returns an appropriate representation of the given header value,
suitable for direct assignment as a header value in an
email.message.Message. RFC2822 assumes that headers contain
only 7-bit characters, so we ensure it is the case, using
RFC2047 encoding when needed.
:param header_text: unicode or utf-8 encoded string with header value
:rtype: string | email.header.Header
:return: if ``header_text`` represents a plain ASCII string,
return the same 7-bit string, otherwise returns an email.header.Header
that will perform the appropriate RFC2047 encoding of
non-ASCII values.
"""
if not header_text: return ""
# convert anything to utf-8, suitable for testing ASCIIness, as 7-bit chars are
# encoded as ASCII in utf-8
header_text_utf8 = tools.ustr(header_text).encode('utf-8')
header_text_ascii = try_coerce_ascii(header_text_utf8)
# if this header contains non-ASCII characters,
# we'll need to wrap it up in a message.header.Header
# that will take care of RFC2047-encoding it as
# 7-bit string.
return header_text_ascii if header_text_ascii\
else Header(header_text_utf8, 'utf-8')
def _write_headers(self, msg):
for h, v in msg.items():
print >> self._fp, '%s:' % h,
if self.__maxheaderlen == 0:
# Explicit no-wrapping
print >> self._fp, v
elif isinstance(v, Header):
# Header instances know what to do
print >> self._fp, v.encode()
elif _is8bitstring(v):
# If we have raw 8bit data in a byte string, we have no idea
# what the encoding is. There is no safe way to split this
# string. If it's ascii-subset, then we could do a normal
# ascii split, but if it's multibyte then we could break the
# string. There's no way to know so the least harm seems to
# be to not split the string and risk it being too long.
print >> self._fp, v
else:
# Header's got lots of smarts, so use it.
print >> self._fp, Header(v,
maxlinelen=self.__maxheaderlen,
header_name=h,
continuation_ws='\t').encode()
# A blank line always separates headers from body
print >> self._fp
def create_message(from_addr, to_addr, subject, body, encoding):
msg = MIMEText(body, 'plain', encoding)
msg['Subject'] = Header(subject, encoding)
msg['From'] = from_addr
msg['To'] = to_addr
msg['Date'] = formatdate()
return msg
def crashed(self, message="Bug in PyKota"):
"""Outputs a crash message, and optionally sends it to software author."""
msg = crashed(message)
fullmessage = "========== Traceback :\n\n%s\n\n========== sys.argv :\n\n%s\n\n========== Environment :\n\n%s\n" % \
(msg, \
"\n".join([" %s" % repr(a) for a in sys.argv]), \
"\n".join([" %s=%s" % (k, v) for (k, v) in os.environ.items()]))
try:
crashrecipient = self.config.getCrashRecipient()
if crashrecipient:
admin = self.config.getAdminMail(
"global") # Nice trick, isn't it ?
server = smtplib.SMTP(self.smtpserver)
msg = MIMEText(fullmessage, _charset=self.charset)
msg["Subject"] = Header("PyKota v%s crash traceback !" \
% __version__, charset=self.charset)
msg["From"] = admin
msg["To"] = crashrecipient
msg["Cc"] = admin
msg["Date"] = email.Utils.formatdate(localtime=True)
server.sendmail(admin, [admin, crashrecipient],
msg.as_string())
server.quit()
except:
pass
return fullmessage
def removeSubscriber(self, subscriber):
charset = self.ploneCharset()
subscriber_email = subscriber.email.strip()
url_service = self.absolute_url()
url_register = "%s/NewsletterTheme_subscribeForm" % url_service
# Make and send the unsubscribe mail
mailMsg=email.Message.Message()
mailMsg["To"]=subscriber_email
mailMsg["From"]=self.authorEmail
mailMsg["Subject"]=str(Header(safe_unicode(self.removeNoticeMailSubject), 'utf8'))
mailMsg["Date"]=email.Utils.formatdate(localtime=1)
mailMsg["Message-ID"]=email.Utils.make_msgid()
mailMsg["Mime-version"]="1.0"
bodyText = self.removeNoticeTemplate % {'url_service': url_service,
'url_register':url_register}
mailMsg["Content-type"]="text/plain"
mailMsg.set_payload(safe_unicode(bodyText).encode(charset), charset)
mailMsg.epilogue="\n" # To ensure that message ends with newline
try:
self.sendmail(self.authorEmail, subscriber_email,
mailMsg, subject = mailMsg['subject'])
except:
log("Could not send a PloneGazzette unsubscribe message to %s, removing subscriber anyway." % subscriber_email)
parent = aq_parent(subscriber)
parent.manage_delObjects([subscriber.id])
def unSubscribe(self, subscriber_id, REQUEST=None):
"""The subscriber clicked the Unsubscribe button
"""
subscriber = self.getSubscriberById(subscriber_id)
if subscriber is not None:
charset = self.ploneCharset()
subscriber_email = subscriber.email.strip()
# Make and send the unsubscribe mail
mailMsg=email.Message.Message()
mailMsg["To"]=subscriber_email
mailMsg["From"]=self.authorEmail
mailMsg["Subject"]=str(Header(safe_unicode(self.unsubscribeMailSubject), 'utf8'))
mailMsg["Date"]=email.Utils.formatdate(localtime=1)
mailMsg["Message-ID"]=email.Utils.make_msgid()
mailMsg["Mime-version"]="1.0"
bodyText = self.unsubscribeMailTemplate % {'email': subscriber_email}
mailMsg["Content-type"]="text/plain"
mailMsg.set_payload(safe_unicode(bodyText).encode(charset), charset)
mailMsg.epilogue="\n" # To ensure that message ends with newline
self.sendmail(self.authorEmail, (subscriber_email,), mailMsg, subject = mailMsg['subject'])
parent = subscriber.aq_parent
newSecurityManager(REQUEST, SpecialUsers.system)
parent.manage_delObjects([subscriber_id,])
if REQUEST is not None:
REQUEST.RESPONSE.redirect(self.absolute_url() + '/NewsletterTheme_unsubscribed')
return
def _send_email(to_addrs, subject, body):
config_in_d = get_config_in_d()
smtp = smtplib.SMTP()
if config_in_d['debug']:
smtp.set_debuglevel(1)
code, msg = smtp.connect(host=config_in_d['smtp_host'],
port=config_in_d['smtp_port'])
assert code == 220
code, msg = smtp.ehlo()
assert code == 250
code, msg = smtp.starttls()
assert code == 220
code, msg = smtp.login(user=config_in_d['username'],
password=config_in_d['password'])
assert code == 235
msg = MIMEMultipart()
text = MIMEText(body, "html", "utf-8")
msg.attach(text)
msg["From"] = config_in_d['username']
msg["To"] = ";".join(to_addrs)
msg["Subject"] = Header(subject, "utf-8")
smtp.sendmail(from_addr=config_in_d['username'],
to_addrs=to_addrs,
msg=msg.as_string())
smtp.quit()
def send_html_email_no_encode(self, smtp, send_from, send_pass, send_tos,
plain_txt, html_content, title):
'''
'''
now = datetime.datetime.now()
today = datetime.date.today()
msg = MIMEMultipart()
body = MIMEMultipart('alternative')
msg['Subject'] = Header(title, "utf-8")
msg['From'] = send_from
text = plain_txt
html = html_content
part_text = MIMEText(text, 'plain', 'utf-8')
body.attach(part_text)
try:
part_html = MIMEText(html, 'html', 'utf-8')
part_html.set_charset('utf-8')
body.attach(part_html)
except:
print 'error html format'
msg.attach(body)
try:
smtp_server = smtplib.SMTP()
smtp_server.connect(smtp)
smtp_server.login(send_from, send_pass)
smtp_server.sendmail(send_from, send_tos, msg.as_string())
smtp_server.close()
except Exception, e:
print "send error:", e
def SendToKindle(filename):
filename = filename + ".txt"
server = 'smtp.163.com'
username = "******"
password = '******'
from_mail = '*****@*****.**'
to_mail = '*****@*****.**'
smtp = smtplib.SMTP()
smtp.connect(server)
smtp.login(username, password)
msg = MIMEMultipart()
msg['to'] = to_mail
msg['from'] = from_mail
msg['Subject'] = "Convert"
msg['Date'] = Utils.formatdate(localtime=1)
content = open(filename, 'rb').read()
att = MIMEText(content, 'base64', 'utf-8')
att['Content-Type'] = 'application/octet-stream'
att["Content-Disposition"] = "attachment;filename=\"%s\"" % Header(
filename, 'gb2312')
msg.attach(att)
smtp.sendmail(msg['from'], msg['to'], msg.as_string())
smtp.quit()
def output(self, protocol=(1, 1)):
"""Transform self into a list of (name, value) tuples."""
header_list = []
for key, v in self.iteritems():
if isinstance(v, unicode):
# HTTP/1.0 says, "Words of *TEXT may contain octets
# from character sets other than US-ASCII." and
# "Recipients of header field TEXT containing octets
# outside the US-ASCII character set may assume that
# they represent ISO-8859-1 characters."
try:
v = v.encode("iso-8859-1")
except UnicodeEncodeError:
if protocol >= (1, 1):
# Encode RFC-2047 TEXT
# (e.g. u"\u8200" -> "=?utf-8?b?6IiA?=").
v = Header(v, 'utf-8').encode()
else:
raise
else:
# This coercion should not take any time at all
# if value is already of type "str".
v = str(v)
header_list.append((key, v))
return header_list
def EnviarCorreo(self, Remitente, Destinatarios): #Método genérico para enviar correo
# Construye el mensaje simple (texto y sin adjunto)
Asunto = self.Asunto.decode('utf-8')
Asunto = Header(Asunto,'utf-8')
Mensaje = MIMEText(self.Mensaje,'plain','utf-8')
Mensaje['From'] = Remitente
Mensaje['To'] = Remitente
Mensaje['Subject'] = Asunto
Mensaje = Mensaje.as_string()
# Conecta con el servidor de correo
if self.Servidor == 'smtp.gmail.com':
try:
mailServer = smtplib.SMTP(self.Servidor,self.Puerto)
mailServer.starttls()
mailServer.login(self.Cuenta, standard_b64decode(self.Pwd))
except:
return 1
else:
try:
mailServer = smtplib.SMTP(self.Servidor, self.Puerto)
# mailServer.set_debuglevel(True) #Usar en caso de requerir ver comunicación con server
except:
return 1
# Envía el mensaje
try:
mailServer.sendmail(Remitente, Destinatarios, Mensaje)
return 0
except:
return 2
finally:
mailServer.quit()
def build_subject(self, status):
subject = self.params['title'].format(**status)
try:
subject.encode('ascii')
return subject
except UnicodeEncodeError:
return Header(subject, self.CHARSET)
def send_email(self, from_address, to_addresses, cc_addresses,
bcc_addresses, subject, body):
"""
Send an email
Args:
to_addresses: must be a list
cc_addresses: must be a list
bcc_addresses: must be a list
"""
try:
# Note: need Python 2.6.3 or more
conn = SMTP_SSL(self.smtp_host, self.smtp_port)
conn.login(self.user, self.password)
msg = MIMEText(body, 'plain', self.email_default_encoding)
msg['Subject'] = Header(subject, self.email_default_encoding)
msg['From'] = from_address
msg['To'] = ', '.join(to_addresses)
if cc_addresses:
msg['CC'] = ', '.join(cc_addresses)
if bcc_addresses:
msg['BCC'] = ', '.join(bcc_addresses)
msg['Date'] = Utils.formatdate(localtime=True)
# TODO: Attached file
conn.sendmail(from_address, to_addresses, msg.as_string())
except:
raise
finally:
conn.close()
def mail(mail_from, mail_password, mail_to, content, fpath_list): # 将多个文件发送至多个接收邮箱
mail_server = mail_server_check(mail_from) # 确定发送邮箱的smtp服务地址
if mail_server: # 确认发送邮箱的smtp地址
msg = MIMEMultipart() # 构建邮件
msg['Subject'] = Header(u'双犬:[RR]随机用户最后登录时间', 'utf-8') # 邮件标题
msg['From'] = mail_from # 邮件发送地址
msg['To'] = ",".join(mail_to) # 邮件接收地址
text_part = MIMEText(content, 'plain', 'utf-8') # 构建以content变量(完成状态)为基础的正文部分
msg.attach(text_part) # 将正文部分补充至邮件中
for file_each in fpath_list: # 对附件列表进行遍历
f = open(file_each, "rb") # 以二进制模式打开将作为附件的文件
file_content = f.read() # 读取文件内容
f.close() # 关闭文件
file_part = MIMEApplication(file_content) # 构建附件部分
file_part.add_header('Content-Disposition', 'attachment', filename = file_each) # 添加附件头信息,以扩展名决定对方的文件打开方式
msg.attach(file_part) # 将附件补充至邮件中
try: # 尝试发送邮件
smtp = smtplib.SMTP(mail_server, 25) # 以25端口构建smtp服务
smtp.ehlo() # 确认smtp服务
smtp.starttls() # 创建TLS连接
smtp.ehlo() # 再次确认smtp服务
smtp.login(mail_from, mail_password) # 登录发送邮箱
smtp.sendmail(mail_from, mail_to, msg.as_string()) # 发送邮件
smtp.quit() # 注销邮箱,退出smtp服务
return u"通知/输出已放出" # 报告通知已经发出
except Exception as ee: # 邮件发送失败
return u"对于" +each_to + u"的通知放出失败:" + str(ee) # 报告邮件发送失败及原因
def sendEmail(self):
"""Sends the email."""
self.send.emit()
msg = MIMEText(self.email_body(), 'plain', 'utf-8')
msg["Subject"] = Header(self.email_subject(),
'utf-8',
continuation_ws=' ')
msg["To"] = self.email_to()
msg["From"] = self.email_from()
msg["Cc"] = self.email_cc()
recipient_list = []
if self.email_to():
recipient_list.extend(self.email_to().split(","))
if self.email_cc():
recipient_list.extend(self.email_cc().split(","))
if self.email_bcc():
recipient_list.extend(self.email_bcc().split(","))
server = smtplib.SMTP('smtp')
server.sendmail(self.email_from(), recipient_list, msg.as_string())
server.quit()
