def postprocess(self, input):
" Heavily borrowed from https://www.mkyong.com/python/how-do-send-email-in-python-via-smtplib/ "
smtpserver = smtplib.SMTP(self.smtp_addr, self.smtp_port)
smtpserver.ehlo()
smtpserver.starttls()
if self.smtp_user and self.smtp_pass:
smtpserver.login(self.smtp_user, self.smtp_pass)
with open(input) as f:
email = Parser().parse(f)
if not self.recipient:
# Set recipients from .mail file
# Multiple recipients can be comma seperated
self.recipient = ','.join(
filter(None,
[email.get('To'), email.get('Cc')]))
else:
# Set To header from config
email['To'] = self.recipient
smtpserver.sendmail(self.smtp_user, self.recipient.split(','),
email.as_string())
smtpserver.close()
def cb_action_ACCEPT(module, filepath):
log.info(_("Accepting message in %s (by module %s)") % (filepath, module))
log.debug(_("Accepting message in: %r") % (filepath), level=8)
# parse message headers
message = Parser().parse(open(filepath, 'r'), True)
sender = [
formataddr(x)
for x in getaddresses(message.get_all('X-Kolab-From', []))
]
recipients = [
formataddr(x) for x in getaddresses(message.get_all('X-Kolab-To', []))
]
log.debug(_("recipients: %r") % (recipients))
# delete X-Kolab-* headers
del message['X-Kolab-From']
del message['X-Kolab-To']
result = _sendmail(
sender,
recipients,
# - Make sure we do not send this as binary.
# - Second, strip NUL characters - I don't know where they
# come from (TODO)
# - Third, a character return is inserted somewhere. It
# divides the body from the headers - and we don't like (TODO)
# @TODO: check if we need Parser().parse() to load the whole message
message.as_string())
if result:
os.unlink(filepath)
def main():
message = """From: Example <*****@*****.**>
This is a message body. Fun!
"""
selector = "_dkim"
signing_domain = "example.com"
secret_key = "-----BEGIN RSA PRIVATE KEY-----\n" \
"MIICXQIBAAKBgQC4GUGr+d/6SFNzVLYpphnRd0QPGKz2uWnV65RAxa1Pw352Bqiz\n" \
"qiKOBjgYGzj8pJQSs8tOvv/2k6jpI809RnESqOFgF0gu3UJbNnu3+cd8k/kiQj+q\n" \
"4cKKRpAT92ccxc7svhCNgN1sBGmROYZuysG3Vu3Dyc079gSLtnSrgXb+gQIDAQAB\n" \
"AoGAemlI0opm1Kvs2T4VliH8/tvX5FXbBH8LEZQAUwVeFTB/UQlieXyCV39pIxZO\n" \
"0Sa50qm8YNL9rb5HTSZiHQFOwyAKNqS4m/7JCsbuH4gQkPgPF561BHNL9oKfYgJq\n" \
"9P4kEFfDTBoXKBMxwWtT7AKV8dYvCa3vYzPQ/1BnqQdw2zECQQDyscdgR9Ih59PQ\n" \
"b72ddibdsxS65uXS2vzYLe7SKl+4R5JgJzw0M6DTAnoYFf6JAsKGZM15PCC0E16t\n" \
"RRo47U9VAkEAwjEVrlQ0/8yPACbDggDJg/Zz/uRu1wK0zjqj4vKjleubaX4SEvj7\n" \
"r6xxZm9hC1pMJAC9y3bbkbgCRBjXfyY6fQJBANe5aq2MaZ41wTOPf45NjbKXEiAo\n" \
"SbUpboKCIbyyaa8V/2h0t7D3C0dE9l4efsguqdZoF7Rh2/f1F70QpYRgfJkCQQCH\n" \
"oRrAeGXP50JVW72fNgeJGH/pnghgOa6of0JpxwhENJuGMZxUDfxTtUA6yD3iXP3j\n" \
"A3WL/wbaHsfOYf9Y+g1NAkAGLhx67Ah+uBNK4Xvfz0YPGINX20m+CMsxAw7FOaNv\n" \
"IW2oWFfZCB4APkIis79Ql45AHpavwx5XodBMzZwJUvlL\n" \
"-----END RSA PRIVATE KEY-----\n"
message = Parser().parsestr(text=message)
dkim.Signer(message, selector, signing_domain, secret_key.encode()).add_signature_to_message()
print(message.as_string())
def prepare_message(email, recipient, recipients_list):
message = email.message
if not message:
return ""
if email.add_unsubscribe_link and email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
unsubscribe_url = get_unsubcribed_url(email.reference_doctype, email.reference_name, recipient,
email.unsubscribe_method, email.unsubscribe_params)
message = message.replace("<!--unsubscribe url-->", quopri.encodestring(unsubscribe_url.encode()).decode())
if email.expose_recipients == "header":
pass
else:
if email.expose_recipients == "footer":
if isinstance(email.show_as_cc, string_types):
email.show_as_cc = email.show_as_cc.split(",")
email_sent_to = [r.recipient for r in recipients_list]
email_sent_cc = ", ".join([e for e in email_sent_to if e in email.show_as_cc])
email_sent_to = ", ".join([e for e in email_sent_to if e not in email.show_as_cc])
if email_sent_cc:
email_sent_message = _("This email was sent to {0} and copied to {1}").format(email_sent_to,email_sent_cc)
else:
email_sent_message = _("This email was sent to {0}").format(email_sent_to)
message = message.replace("<!--cc message-->", quopri.encodestring(email_sent_message.encode()).decode())
message = message.replace("<!--recipient-->", recipient)
message = (message and message.encode('utf8')) or ''
if not email.attachments:
return message
# On-demand attachments
from email.parser import Parser
msg_obj = Parser().parsestr(message)
attachments = json.loads(email.attachments)
for attachment in attachments:
if attachment.get('fcontent'): continue
fid = attachment.get("fid")
if fid:
fname, fcontent = get_file(fid)
attachment.update({
'fname': fname,
'fcontent': fcontent,
'parent': msg_obj
})
attachment.pop("fid", None)
add_attachment(**attachment)
elif attachment.get("print_format_attachment") == 1:
attachment.pop("print_format_attachment", None)
print_format_file = frappe.attach_print(**attachment)
print_format_file.update({"parent": msg_obj})
add_attachment(**print_format_file)
return msg_obj.as_string()
def prepare_message(email, recipient, recipients_list):
message = email.message
if not message:
return ""
if email.add_unsubscribe_link and email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
unsubscribe_url = get_unsubcribed_url(email.reference_doctype, email.reference_name, recipient,
email.unsubscribe_method, email.unsubscribe_params)
message = message.replace("<!--unsubscribe url-->", quopri.encodestring(unsubscribe_url.encode()).decode())
if email.expose_recipients == "header":
pass
else:
if email.expose_recipients == "footer":
if isinstance(email.show_as_cc, string_types):
email.show_as_cc = email.show_as_cc.split(",")
email_sent_to = [r.recipient for r in recipients_list]
email_sent_cc = ", ".join([e for e in email_sent_to if e in email.show_as_cc])
email_sent_to = ", ".join([e for e in email_sent_to if e not in email.show_as_cc])
if email_sent_cc:
email_sent_message = _("This email was sent to {0} and copied to {1}").format(email_sent_to,email_sent_cc)
else:
email_sent_message = _("This email was sent to {0}").format(email_sent_to)
message = message.replace("<!--cc message-->", quopri.encodestring(email_sent_message.encode()).decode())
message = message.replace("<!--recipient-->", recipient)
message = (message and message.encode('utf8')) or ''
if not email.attachments:
return message
# On-demand attachments
from email.parser import Parser
msg_obj = Parser().parsestr(message)
attachments = json.loads(email.attachments)
for attachment in attachments:
if attachment.get('fcontent'): continue
fid = attachment.get("fid")
if fid:
fname, fcontent = get_file(fid)
attachment.update({
'fname': fname,
'fcontent': fcontent,
'parent': msg_obj
})
attachment.pop("fid", None)
add_attachment(**attachment)
elif attachment.get("print_format_attachment") == 1:
attachment.pop("print_format_attachment", None)
print_format_file = frappe.attach_print(**attachment)
print_format_file.update({"parent": msg_obj})
add_attachment(**print_format_file)
return msg_obj.as_string()
def send_email(to, subject, body):
msg = Parser().parsestr(
'From: <*****@*****.**>\n' + 'To: <' +
to + '>\n' + 'Subject: ' + subject + '\n' + '\n' + '' + body + '\n')
if not DEBUG:
s = smtplib.SMTP('localhost')
s.sendmail('*****@*****.**', [to],
msg.as_string())
s.quit()
else:
print msg
def do_email(msg_content, ip):
# 稍后解析出邮件:
msg = Parser().parsestr(msg_content)
email_str = msg.as_string()
p = ParseEmail(email_str)
m = p.parseMailTemplate()
text = m.get('html_text', '').strip()
if not text: text = m.get('plain_text', '')
ip_info = "IP Address {} from the Spamhaus PBL database".format(ip)
if text.find(ip_info) > 0:
m = re.search(r"Verification/Confirmation Code:\s+(\d+)", text)
if m: return m.group(1)
return None
def send_email(to, subject, body):
msg = Parser().parsestr('From: <*****@*****.**>\n' +
'To: <'+ to + '>\n' +
'Subject: '+ subject + '\n' +
'\n' +
'' + body + '\n')
if not DEBUG:
s = smtplib.SMTP('localhost')
s.sendmail('*****@*****.**', [to], msg.as_string())
s.quit()
else:
print msg
def do_email(msg_content, mail_to):
# 稍后解析出邮件:
msg = Parser().parsestr(msg_content)
email_str = msg.as_string()
p = parse_email.ParseEmail(email_str)
m = p.parseMailTemplate()
try:
text = html2text.beautifulsoup_html2text(
m.get('html_text', '').decode(m.get('html_charset', 'utf-8'),
errors='ignore').encode('utf-8'))
return do_email_text(text, mail_to)
except:
return None, None
def send_msg(args):
# The Database needs to be open to build Chains and for Mix to encode
# messages.
with sqlite3.connect(dbkeys()) as conn:
conn.text_factory = str
# Create a message object, either from file or stdin.
if args.filename:
with open(args.filename, 'r') as f:
msg = Parser().parse(f)
else:
sys.stdout.write("Type message here. Finish with Ctrl-D.\n")
msg = Parser().parsestr(sys.stdin.read())
# Create or override important headers
if args.recipient:
msg['To'] = args.recipient
if args.sender:
msg['From'] = args.sender
if args.subject:
msg['Subject'] = args.subject
if 'To' not in msg:
sys.stderr.write("Message has no recipient specified.\nUse "
"\"--recipient RECIPIENT_ADDRESS\" "
"to add one.\n")
sys.exit(1)
if 'From' not in msg:
msg['From'] = config.get('general', 'sender')
m = mix.send(conn, msg.as_string(), args.chainstr)
if args.stdout:
sys.stdout.write(m.text)
else:
payload = {'base64': m.text}
url = '%s/collector.py/msg' % m.send_to_address
try:
# Send the message to the first hop.
r = requests.post(url, data=payload)
if r.status_code == requests.codes.ok:
sys.stdout.write("Message delivered to %s\n"
% m.send_to_address)
else:
sys.stderr.write("Delivery to %s failed with status "
"code: %s.\n" % (url, r.status_code))
except requests.exceptions.ConnectionError:
#TODO Mark down remailer statistics.
sys.stderr.write("Unable to connect to %s.\n"
% m.send_to_address)
def write_reply(self, template, buildlog, args):
with open(template, 'r') as fd:
substdict = dict(args)
substdict['buildlog'] = buildlog
substdict['fromaddr'] = self.fromaddr
substdict['lintlog'] = 'No log'
if self.lintlog:
self.dependencies = ['Lintian']
lintfile = os.path.join(self.resultdir, '%s.lintian'
% args['package'])
if os.path.isfile(lintfile):
with open(lintfile, 'r') as lintfd:
substdict['lintlog'] = lintfd.read()
reply = fd.read() % substdict
msg = Parser().parsestr(reply)
return msg.as_string()
def write_reply(self, template, buildlog, package):
lintianoutput = 'No log'
with open(template, 'r') as fd:
if self.lintian:
lintfile = os.path.join(self.resultdir, '%s.lintian' % package)
if os.path.isfile(lintfile):
with open(lintfile, 'r') as lintfd:
lintianoutput = lintfd.read()
params = {'sender': self.sender,
'uploader': self.uploader,
'package': package,
'buildlog': buildlog,
'lintian': lintianoutput}
reply = fd.read() % params
msg = Parser().parsestr(reply)
return msg.as_string().encode('utf-8')
def send_email(cfg, email_body):
"""Send email."""
try:
server = smtplib.SMTP(cfg["smtp-server"], port=cfg["smtp-port"])
server.set_debuglevel(1)
to_addresses = EMAIL_SPLIT_RE.split(cfg["destination-emails"].strip())
message = Parser().parsestr(email_body)
message["Date"] = formatdate(localtime=True)
server.sendmail(cfg["source-email"],
to_addresses,
message.as_string())
server.quit()
return True
except (smtplib.SMTPException, socket.error, EnvironmentError) as e:
logging.getLogger("%s.Notifications" % __name__).exception(e)
return False
def write_reply(self, template, buildlog, package):
lintianoutput = 'No log'
with open(template, 'r') as fd:
if self.lintian:
lintfile = os.path.join(self.resultdir, '%s.lintian' % package)
if os.path.isfile(lintfile):
with open(lintfile, 'r') as lintfd:
lintianoutput = lintfd.read()
params = {
'sender': self.sender,
'uploader': self.uploader,
'package': package,
'buildlog': buildlog,
'lintian': lintianoutput
}
reply = fd.read() % params
msg = Parser().parsestr(reply)
return msg.as_string().encode('utf-8')
def lambda_handler(event, context):
for record in event['Records']:
bucket = record["s3"]["bucket"]["name"]
key = record["s3"]["object"]["key"]
obj = s3.Object(bucket, key)
raw_contents = obj.get()['Body'].read()
msg = Parser(policy=policy.default).parsestr(
raw_contents.decode('utf-8'))
orig_to = msg['to']
orig_subject = msg['subject']
print('To: ', msg['to'])
print('From: ', msg['from'])
print('Subject: ', msg['subject'])
account = get_account_info(msg['to'])
del msg['DKIM-Signature']
del msg['Sender']
del msg['subject']
del msg['Source']
del msg['From']
del msg['Return-Path']
msg['subject'] = "[{}]: {}".format(account.account_id, orig_subject)
try:
response = ses_client.send_raw_email(
RawMessage=dict(Data=msg.as_string()),
Destinations=[account.internal_email_address],
Source=orig_to)
except ClientError as e:
print(e.response['Error']['Message'])
raise e
else:
print("Email sent. Message ID: ", response['MessageId'])
return {
"statusCode": 200,
"body": json.dumps(response),
}
def send_email(cfg, email_body):
"""Send email."""
try:
server = smtplib.SMTP(cfg["smtp-server"],
port=cfg["smtp-port"],
timeout=float(cfg["smtp-timeout"]))
server.set_debuglevel(1)
to_addresses = EMAIL_SPLIT_RE.split(cfg["destination-emails"].strip())
message = Parser().parsestr(email_body)
message["Date"] = formatdate(localtime=True)
server.sendmail(cfg["source-email"], to_addresses, message.as_string())
server.quit()
return True
except (smtplib.SMTPException, socket.error, EnvironmentError,
socket.timeout, ValueError) as e:
logging.getLogger("{0}.Notifications".format(__name__)).exception(e)
return False
def testStripLeapHeaders(self):
ENC_HEADER = "fake encryption header"
SIG_HEADER = "fake signature header"
message = Parser().parsestr(self.EMAIL)
message.add_header("X-Leap-Encryption", ENC_HEADER)
message.add_header("X-Leap-Signature", SIG_HEADER)
self.fetcher._add_message_locally = Mock()
def check_headers(_):
self.assertTrue(self.fetcher._add_message_locally.called,
"The message was not added to soledad")
_, data = self.fetcher._add_message_locally.call_args[0][0]
msg = Parser().parsestr(data)
self.assertNotEqual(msg.get('X-Leap-Encryption', ''), ENC_HEADER)
self.assertNotEqual(msg.get('X-Leap-Signature', ''), SIG_HEADER)
d = self._do_fetch(message.as_string())
d.addCallback(check_headers)
return d
def process_message(self, peer, mailfrom, rcpttos, data):
# Print the request information
sys.stdout.write(u"Receiving message from: %s\n" % str(peer))
sys.stdout.write(u"Message addressed from: %s\n" % str(mailfrom))
sys.stdout.write(u"Message addressed to: %s\n" % str(rcpttos))
sys.stdout.write(u"Message length: %s\n" % str(len(data)))
sys.stdout.flush()
# Parse the message and remove headers that are offensive to SES
msg = Parser().parsestr(data)
if 'Errors-To' in msg:
del msg['Errors-To']
# Send out via SES
try:
connection = SESConnection(aws_access_key_id=self.aws_key,
aws_secret_access_key=self.aws_secret)
connection.send_raw_email(msg.as_string(), source=mailfrom)
except BotoServerError, err:
sys.stderr.write(str(err))
sys.stdout.flush()
def testExtractOpenPGPHeaderInvalidUrl(self):
"""
Test the OpenPGP header key extraction
"""
KEYURL = "https://someotherdomain.com/key.txt"
OpenPGP = "id=12345678; url=\"%s\"; preference=signencrypt" % (KEYURL,)
message = Parser().parsestr(self.EMAIL)
message.add_header("OpenPGP", OpenPGP)
self.fetcher._keymanager.fetch_key = Mock()
def fetch_key_called(ret):
self.assertFalse(self.fetcher._keymanager.fetch_key.called)
d = self._create_incoming_email(message.as_string())
d.addCallback(
lambda email:
self._mock_soledad_get_from_index(fields.JUST_MAIL_IDX, [email]))
d.addCallback(lambda _: self.fetcher.fetch())
d.addCallback(fetch_key_called)
return d
def testExtractOpenPGPHeaderInvalidUrl(self):
"""
Test the OpenPGP header key extraction
"""
KEYURL = "https://someotherdomain.com/key.txt"
OpenPGP = "id=12345678; url=\"%s\"; preference=signencrypt" % (KEYURL,)
message = Parser().parsestr(self.EMAIL)
message.add_header("OpenPGP", OpenPGP)
self.fetcher._keymanager.fetch_key = Mock()
def fetch_key_called(ret):
self.assertFalse(self.fetcher._keymanager.fetch_key.called)
d = self._create_incoming_email(message.as_string())
d.addCallback(
lambda email:
self._mock_soledad_get_from_index(fields.JUST_MAIL_IDX, [email]))
d.addCallback(lambda _: self.fetcher.fetch())
d.addCallback(fetch_key_called)
return d
def process_message(self, peer, mailfrom, rcpttos, data):
# Print the request information
sys.stdout.write(u"Receiving message from: %s\n" % str(peer))
sys.stdout.write(u"Message addressed from: %s\n" % str(mailfrom))
sys.stdout.write(u"Message addressed to: %s\n" % str(rcpttos))
sys.stdout.write(u"Message length: %s\n" % str(len(data)))
sys.stdout.flush()
# Parse the message and remove headers that are offensive to SES
msg = Parser().parsestr(data)
if 'Errors-To' in msg:
del msg['Errors-To']
# Send out via SES
try:
connection = SESConnection(aws_access_key_id=self.aws_key,
aws_secret_access_key=self.aws_secret)
connection.send_raw_email(msg.as_string(), source=mailfrom)
except BotoServerError, err:
sys.stderr.write(str(err))
sys.stdout.flush()
def cb_action_ACCEPT(module, filepath):
log.info(_("Accepting message in %s (by module %s)") % (filepath, module))
log.debug(_("Accepting message in: %r") %(filepath), level=8)
# parse message headers
message = Parser().parse(open(filepath, 'r'), True)
sender = [formataddr(x) for x in getaddresses(message.get_all('X-Kolab-From', []))]
recipients = [formataddr(x) for x in getaddresses(message.get_all('X-Kolab-To', []))]
log.debug(_("recipients: %r") % (recipients))
# delete X-Kolab-* headers
del message['X-Kolab-From']
del message['X-Kolab-To']
smtp = smtplib.SMTP("localhost", 10027)
if conf.debuglevel > 8:
smtp.set_debuglevel(True)
try:
smtp.sendmail(
sender,
recipients,
# - Make sure we do not send this as binary.
# - Second, strip NUL characters - I don't know where they
# come from (TODO)
# - Third, a character return is inserted somewhere. It
# divides the body from the headers - and we don't like (TODO)
# @TODO: check if we need Parser().parse() to load the whole message
message.as_string()
)
except smtplib.SMTPDataError, errmsg:
log.error("SMTP Data Error, %r" % (errmsg))
# DEFER
pass
def post(self):
"""
This actually sends out the email when the existing user clicks 'send'
"""
currentinvitee = self.graph.invitees.index.lookup(\
email=self.get_argument("email"))
# check to see if this email has already been invited.
# If it has, remove all of its previos occurrences
if ( currentinvitee is not None ):
for current in currentinvitee:
self.graph.invitees.delete(current.eid)
#creates an Invitee object with the given email and a generated uuid
currentinvitee = self.graph.invitees.create(
email=self.get_argument("email"),
token=uuid.uuid4().hex)
#TODO: Does this need to be more secure?
currentuser = self.graph.users.index.lookup(\
userid=self.get_secure_cookie("userid")).next()
self.graph.invited.create(currentuser, currentinvitee)
## build the email and send it. SMTP host is localhost for now.
s = smtplib.SMTP('localhost')
headers = Parser().parsestr('From: <[email protected])\n'
'To: <'+ self.get_argument("email") +'>\n'
'Subject: You have been invited to enclav.es\n'
'\n'
## TODO: Write out a better invite email
'Click here to accept the invitation: http://enclav.es/sign-up?token='\
+currentinvitee.token+'\n')
s.sendmail(headers['from'],[headers['to']],headers.as_string())
self.redirect("/invite")
def testExtractOpenPGPHeader(self):
"""
Test the OpenPGP header key extraction
"""
KEYURL = "https://leap.se/key.txt"
OpenPGP = "id=12345678; url=\"%s\"; preference=signencrypt" % (KEYURL,)
message = Parser().parsestr(self.EMAIL)
message.add_header("OpenPGP", OpenPGP)
self.fetcher._keymanager.fetch_key = Mock(
return_value=defer.succeed(None))
def fetch_key_called(ret):
self.fetcher._keymanager.fetch_key.assert_called_once_with(
ADDRESS_2, KEYURL, OpenPGPKey)
d = self._create_incoming_email(message.as_string())
d.addCallback(
lambda email:
self._mock_soledad_get_from_index(fields.JUST_MAIL_IDX, [email]))
d.addCallback(lambda _: self.fetcher.fetch())
d.addCallback(fetch_key_called)
return d
def testExtractOpenPGPHeader(self):
"""
Test the OpenPGP header key extraction
"""
KEYURL = "https://leap.se/key.txt"
OpenPGP = "id=12345678; url=\"%s\"; preference=signencrypt" % (KEYURL,)
message = Parser().parsestr(self.EMAIL)
message.add_header("OpenPGP", OpenPGP)
self.fetcher._keymanager.fetch_key = Mock(
return_value=defer.succeed(None))
def fetch_key_called(ret):
self.fetcher._keymanager.fetch_key.assert_called_once_with(
ADDRESS_2, KEYURL, OpenPGPKey)
d = self._create_incoming_email(message.as_string())
d.addCallback(
lambda email:
self._mock_soledad_get_from_index(fields.JUST_MAIL_IDX, [email]))
d.addCallback(lambda _: self.fetcher.fetch())
d.addCallback(fetch_key_called)
return d
def walk_domain(domain, path):
new_path = os.path.join(path, 'new')
email_filenames = os.listdir(new_path)
email_count = len(email_filenames)
print 'Reading %s, %d emails.' % (domain, email_count)
for i, email_filename in enumerate(email_filenames):
email_filepath = os.path.join(new_path, email_filename)
try:
message = Parser().parse(open(email_filepath, 'r'))
email = Email()
email.domain = domain
email.header_from = message['from']
email.header_to = message['to']
email.header_subject = message['subject']
email.header_date = parser.parse(message['date'])
email.postgres_filename = email_filename
email.original = message.as_string()
session.add(email)
session.commit()
cur_path = os.path.join(path, 'cur')
os.rename(email_filepath, os.path.join(cur_path, email_filename))
except Exception, exc:
print exc
fail_path = os.path.join(path, 'fail')
if not os.path.exists(fail_path):
os.makedirs(fail_path)
os.rename(email_filepath, os.path.join(fail_path, email_filename))
stdout('\r%5d/%5d : %0.2f%%' % (i, email_count, i * 100.0 / email_count))
f = feedparser.parse('http://www.asti.dost.gov.ph/job-opportunities?format=feed&type=rss')
#f = feedparser.parse('http://twitrss.me/twitter_user_to_rss/?user=intel')
print "Date now in UTC: "
print datetime.utcnow()
job_items = ""
for item in f.entries:
publishedDate = parse(item.published)
if publishedDate.day == datetime.utcnow().day and publishedDate.month == datetime.utcnow().month:
#print item.published
#print publishedDate
#print item.title
#print item.link
job_items = job_items + item.title + "\n" + item.link + "\n\n"
if job_items != "":
print job_items
mail_content = Parser().parsestr('From: mail@localhost \n'
'To: [email protected]\n'
'Subject: Test\n'
'\n'
'%s' % job_items)
server = smtplib.SMTP('smtp.sendgrid.net')
server.login('scrapy', 'scrapy123')
server.sendmail(mail_content['from'], mail_content['to'], mail_content.as_string())
server.quit()
def execute(*args, **kw):
if not os.path.isdir(mybasepath):
os.makedirs(mybasepath)
for stage in ['incoming', 'ACCEPT' ]:
if not os.path.isdir(os.path.join(mybasepath, stage)):
os.makedirs(os.path.join(mybasepath, stage))
# TODO: Test for correct call.
filepath = args[0]
if kw.has_key('stage'):
log.debug(_("Issuing callback after processing to stage %s") % (kw['stage']), level=8)
log.debug(_("Testing cb_action_%s()") % (kw['stage']), level=8)
if hasattr(modules, 'cb_action_%s' % (kw['stage'])):
log.debug(_("Attempting to execute cb_action_%s()") % (kw['stage']), level=8)
exec('modules.cb_action_%s(%r, %r)' % (kw['stage'],'optout',filepath))
return
log.debug(_("Executing module footer for %r, %r") % (args, kw), level=8)
new_filepath = os.path.join('/var/spool/pykolab/wallace/footer/incoming', os.path.basename(filepath))
os.rename(filepath, new_filepath)
filepath = new_filepath
# parse message headers
# @TODO: make sure we can use True as the 2nd argument here
message = Parser().parse(open(filepath, 'r'), True)
# Possible footer answers are limited to ACCEPT only
answers = [ 'ACCEPT' ]
footer = {}
footer_html_file = conf.get('wallace', 'footer_html')
footer_text_file = conf.get('wallace', 'footer_text')
if not os.path.isfile(footer_text_file) and not os.path.isfile(footer_html_file):
exec('modules.cb_action_%s(%r, %r)' % ('ACCEPT','footer', filepath))
return
if os.path.isfile(footer_text_file):
footer['plain'] = open(footer_text_file, 'r').read()
if not os.path.isfile(footer_html_file):
footer['html'] = '<p>' + self.footer['plain'] + '</p>'
else:
footer['html'] = open(footer_html_file, 'r').read()
if footer['html'] == "":
footer['html'] = '<p>' + self.footer['plain'] + '</p>'
if footer['plain'] == "" and footer['html'] == "<p></p>":
exec('modules.cb_action_%s(%r, %r)' % ('ACCEPT','footer', filepath))
return
footer_added = False
try:
_footer_added = message.get("X-Wallace-Footer")
except:
pass
if _footer_added == "YES":
exec('modules.cb_action_%s(%r, %r)' % ('ACCEPT','footer', filepath))
return
if message.is_multipart():
if message.get_content_type() == "multipart/alternative":
log.debug("The message content type is multipart/alternative.")
for part in message.walk():
disposition = None
try:
content_type = part.get_content_type()
except:
continue
try:
disposition = part.get("Content-Disposition")
except:
pass
if not disposition == None:
continue
if content_type == "text/plain":
content = part.get_payload()
content += "\n\n--\n%s" % (footer['plain'])
part.set_payload(content)
footer_added = True
elif content_type == "text/html":
content = part.get_payload()
content += "\n<!-- footer appended by Wallace -->\n"
content += "\n<html><body><hr />%s</body></html>\n" % (footer['html'])
part.set_payload(content)
footer_added = True
else:
# Check the main content-type.
if message.get_content_type() == "text/html":
content = message.get_payload()
content += "\n<!-- footer appended by Wallace -->\n"
content += "\n<html><body><hr />%s</body></html>\n" % (footer['html'])
message.set_payload(content)
footer_added = True
else:
content = message.get_payload()
content += "\n\n--\n%s" % (footer['plain'])
message.set_payload(content)
footer_added = True
if footer_added:
log.debug("Footer attached.")
message.add_header("X-Wallace-Footer", "YES")
(fp, new_filepath) = tempfile.mkstemp(dir="/var/spool/pykolab/wallace/footer/ACCEPT")
os.write(fp, message.as_string())
os.close(fp)
os.unlink(filepath)
exec('modules.cb_action_%s(%r, %r)' % ('ACCEPT','footer', new_filepath))
for msg_id in data[0].split(' '):
if msg_id:
if get_conf('secrets', 'debug'):
print('parsing msg_id=%s' % msg_id)
syslog.syslog('parsing msg_id=%s' % msg_id)
typ, data = imapclient.fetch(msg_id, '(RFC822)')
message = Parser().parsestr(data[0][1])
from_data = message.get('From')
to_data = message.get('To')
subject = message.get('Subject')
if not parseaddr(to_data)[1]:
continue
dbcursor.execute(
'SELECT support_email FROM vendors WHERE kiosk_email=(%s)',
(to_data, ))
if dbcursor.rowcount == 0:
syslog.syslog("kiosk_email=%s not found" % to_data)
continue
else:
support_email = dbcursor.fetchone().support_email
if support_email is None:
syslog.syslog("support_email=none")
continue
else:
mailer(message.as_string(), support_email)
if __name__ == "__main__":
signal.signal(signal.SIGINT, sigint_handler)
main()
addr = addr_subj(msg)[0]
subj = addr_subj(msg)[1]
# Initialize the searchname and searchnumber
searchname = "?"
searchnumber = "?"
if len(subj.split())>0:
searchname = subj.split()[0]
if len(subj.split())>1:
searchnumber = subj.split()[1]
# Initialize the searchgrade to check if it will be changed
searchgrade = "?"
# Search grade, if successful, then change "searchgrade" to the real grade
for i in range(student_number):
if (searchname == name[i]) and (searchnumber == number[i]) and (addr == corr_addr[i]):
searchgrade = grade[i]
# If search successfully, then reply
if (searchgrade != "?"):
send_str = "Your grade is "+searchgrade
msg = MIMEText(send_str, 'plain', 'utf-8')
msg['subject'] = 'Grade of the middle-term exam'
msg['from'] = "Quantum Mechanics B"
msg['to'] = addr
smtp_server.sendmail(email, [addr], msg.as_string())
# Delete mail directly from the server according to the mail index number:
pop3_server.dele(index)
pop3_server.quit() #quit pop3
# quit smtp, we don't need it
#smtp_server.quit()
def header_check (db, cl, nodeid, new_values) :
""" Check header of new messages and determine original customer
from that header -- only if sender is the support special
account (any account with system status). If send_to_customer
flag is set *and* account is not a system account, munge
the headers and add X-ROUNDUP-TO and X-ROUNDUP-CC headers.
"""
send_to_customer = False
# Be sure to alway set send_to_customer to False!
if 'send_to_customer' in new_values :
send_to_customer = new_values ['send_to_customer']
new_values ['send_to_customer'] = False
newmsgs = new_values.get ('messages')
if not newmsgs :
return
newmsgs = set (newmsgs)
if nodeid :
oldmsgs = set (cl.get (nodeid, 'messages'))
else :
oldmsgs = set ()
system = db.user_status.lookup ('system')
cemail = db.contact_type.lookup ('Email')
for msgid in newmsgs.difference (oldmsgs) :
msg = db.msg.getnode (msgid)
h = None
if msg.header :
h = Parser ().parsestr (msg.header, headersonly = True)
else :
h = Message ()
if db.user.get (msg.author, 'status') == system :
frm = fix_emails (h.get_all ('From'))
subj = header_utf8 (h.get_all ('Subject') [0])
if ( frm
and 'customer' not in new_values
and 'emails' not in new_values
) :
cc = {}
if not nodeid :
# use only first 'From' address (there shouldn't be more)
rn, mail = getaddresses (frm) [0]
# the *to* address in this mail is the support user we
# want as a from-address for future mails *to* this user
autad = None
hto = fix_emails (h.get_all ('To'))
if hto :
torn, autad = getaddresses (hto) [0]
if not autad.startswith ('support') :
autad = None
c = find_or_create_contact \
(db, mail, rn, frm = autad, subject = subj)
cust = new_values ['customer'] = \
db.contact.get (c, 'customer')
new_values ['emails'] = [c]
else :
supi = cl.getnode (nodeid)
cust = supi.customer
new_values ['emails'] = supi.emails
new_values ['cc_emails'] = supi.cc_emails
if supi.cc :
cc = dict.fromkeys \
(x.strip ().lower () for x in supi.cc.split (','))
# Parse To and CC headers to find more customer email
# addresses. Check if these contain the same domain
# part as the From.
ccs = h.get_all ('CC') or []
tos = h.get_all ('To') or []
if nodeid :
tos.extend (frm)
cfrm = db.customer.get (cust, 'fromaddress')
alltocc = dict.fromkeys (new_values ['emails'])
if 'cc_emails' in new_values :
alltocc.update (dict.fromkeys (new_values ['cc_emails']))
for addrs, field in ((tos, 'emails'), (ccs, 'cc_emails')) :
addrs = fix_emails (addrs)
for rn, mail in getaddresses (addrs) :
if mail == cfrm :
continue
c = find_or_create_contact \
(db, mail, rn, customer = cust)
if c :
if field not in new_values :
new_values [field] = []
if c not in alltocc :
new_values [field].append (c)
alltocc [c] = 1
elif uidFromAddress (db, (rn, mail), create = 0) :
# ignore internal addresses
pass
else :
cc [mail.lower ()] = 1
if cc :
new_values ['cc'] = ', '.join (cc.keys ())
else :
if send_to_customer :
mails = []
cc = []
if 'emails' in new_values :
mails = new_values ['emails']
elif nodeid :
mails = cl.get (nodeid, 'emails')
if 'cc_emails' in new_values :
mcc = new_values ['cc_emails']
elif nodeid :
mcc = cl.get (nodeid, 'cc_emails')
mails = mails or []
mcc = mcc or []
mails = (db.contact.get (x, 'contact') for x in mails)
mcc = (db.contact.get (x, 'contact') for x in mcc)
if 'cc' in new_values :
cc = new_values ['cc']
elif nodeid :
cc = cl.get (nodeid, 'cc')
m = ','.join (mails)
mc = ','.join (mcc)
if mc :
if cc :
mc = ','.join ((mc, cc))
else :
mc = cc
if not m and not mc :
raise Reject, \
_ ("Trying to send to customer with empty CC and "
"without configured contact-email for customer"
)
if m :
h.add_header ('X-ROUNDUP-TO', m)
if mc :
h.add_header ('X-ROUNDUP-CC', mc)
if 'bcc' in new_values :
bcc = new_values ['bcc']
elif nodeid :
bcc = cl.get (nodeid, 'bcc')
if bcc :
h.add_header ('X-ROUNDUP-BCC', bcc)
# Time-Stamp of first reply to customer
if not nodeid or not cl.get (nodeid, 'first_reply') :
new_values ['first_reply'] = Date ('.')
h = h.as_string ()
if h != '\n' and h != msg.header :
db.msg.set (msgid, header = h)
class Message(object):
def __init__(self, imap, uid):
self.__imap = imap
self.__uid = uid
self.__cache = {}
data = ImapResult(self.__imap.uid('fetch', self.__uid, '(BODY.PEEK[HEADER])'))
raw_headers = data[0][1]
self.__header_size = len(raw_headers)
self.__headers = Parser().parsestr(raw_headers)
def print_headers(self):
print ' subject: %s' % (self.subject,)
print ' from: %s' % (self.froms,)
print ' to: %s' % (self.tos,)
if self.ccs:
print ' cc: %s' % (self.ccs,)
print ' date: %s' % (self.date,)
# print ' received: %s' % (repr(self.received),)
print ' uid: %s' % self.uid
def raw_email(self):
data = ImapResult(self.__imap.uid('fetch', self.__uid, '(RFC822.PEEK)'))
raw_email = data[0][1]
return raw_email
def raw_body(self, part=None, skip=0, take=0):
if part is None:
skip = self.__header_size + skip
if take == 0:
span = '<%d.>' % (skip,)
else:
span = '<%d.%d>' % (skip, take)
if part is None:
part = ''
else:
part = '[%d]' % part
expr = '(BODY.PEEK%s%s)' % (part, span)
resp = ImapResult(self.__imap.uid('fetch', self.__uid, expr))
response, data = resp[0]
reLen = re.compile('.*<(?P<start>\d+)> \{(?P<len>\d+)\}.*')
m = reLen.match(response)
len = int(m.group('len'))
return data
#decorator
def _cache(func): # pylint: disable=E0213
def _cache_(self, *args, **kwargs):
if func.__name__ in self.__cache:
return self.__cache[func.__name__]
value = func(self, *args, **kwargs) # pylint: disable=E1102
self.__cache[func.__name__] = value
return value
return _cache_
@property
@_cache
def subject(self):
return self.__headers['subject'].replace('\r\n', ' ').replace('\n\r', ' ').replace('\n', ' ').replace(' ', ' ')
@property
@_cache
def date(self):
return dateutil.parser.parse(self.__headers['date'])
@property
def uid(self):
return self.__uid
@property
@_cache
def froms(self):
return AddressField(self.__headers, 'from')
@property
@_cache
def tos(self):
return AddressField(self.__headers, 'to')
@property
@_cache
def ccs(self):
return AddressField(self.__headers, 'cc')
@property
@_cache
def bccs(self):
return AddressField(self.__headers, 'bcc')
@property
@_cache
def all_tos(self):
return AddressField(self.__headers, ('to', 'cc', 'bcc'))
@property
@_cache
def received(self):
t = self.__headers['received']
if t:
t = t.split(";", 1)[1]
t = t.lstrip()
d = dateutil.parser.parse(t)
return time.mktime(d.timetuple())
t = self.__headers['date']
if t:
d = dateutil.parser.parse(t)
return time.mktime(d.timetuple())
print self.__headers.as_string()
raise Exception("Can't establish delivery time")
def move(self, folder):
try:
print " --> %s" % folder
data = ImapResult(self.__imap.uid('COPY', self.__uid, folder))
data = ImapResult(self.__imap.uid('STORE', self.__uid, '+FLAGS', '(\Deleted)'))
self.__imap.expunge()
return True
except ImapResultError, e:
import sys
print >> sys.stderr, '! %s' % e
def import_mail_problem_address(self, cr, uid, ids, context=None):
''' Check error message folder and parse name for check error in
partner mail address
'''
# Utility:
def clean(all_mail, mail_sent):
''' Remove not necessary mail
'''
res = []
for email in all_mail:
if email in mail_sent and email not in res:
res.append(email)
return res
partner_pool = self.pool.get('res.partner')
# Read base folder for mailing
error_path = self.pool.get('res.company').get_base_local_folder(
cr, uid, subfolder='mailing_error', context=context)
error_path = os.path.expanduser(error_path)
# Read 2 subfolder for mailing:
mail_path = os.path.join(error_path, 'mail')
csv_path = os.path.join(error_path, 'csv')
# Create if not existe 2 subfolder paths
os.system('mkdir -p %s' % mail_path)
os.system('mkdir -p %s' % csv_path)
# ---------------------------------------------------------------------
# Read all mail in newsletter
# ---------------------------------------------------------------------
file_mail = os.path.join(csv_path, 'mail.csv')
mail_sent = {}
for address in open(file_mail, 'r'):
address = address.strip()
partner_ids = partner_pool.search(cr,
uid, [
('email', '=', address),
],
context=context)
# TODO test partner not present
mail_sent[address] = partner_ids
# ---------------------------------------------------------------------
# Read all mail in error mail folder
# ---------------------------------------------------------------------
for mail_file in [f for f in os.listdir(mail_path)]:
mail_fullfile = os.path.join(mail_path, mail_file)
message = Parser().parse(open(mail_fullfile, 'r'))
# Parse message parameters:
subject = message['subject'].replace('\n', '').replace('\r', '')
mail_to = message['to']
mail_from = message['from']
# Extract list of mail address in mail text file:
all_mail = clean(
re.findall(r'[\w\.-]+@[\w\.-]+', message.as_string()),
mail_sent,
)
for mail_found in all_mail:
partner_error_ids = mail_sent.get(mail_found, False)
if partner_error_ids:
partner_pool.write(cr,
uid,
partner_error_ids, {
'address_error':
True,
'address_error_text':
'Subject: %s\nFrom: %s To: %s' % (
subject,
mail_from,
mail_to,
)
},
context=context)
# TODO delete file after update res.partner
# Extract mail:
#try:
# mail_address = mail.split('<')[1].split('>')[0]
#except:
# mail_address = mail
# ---------------------------------------------------------------------
# Search customer mail for mark problem
# ---------------------------------------------------------------------
partner_error_ids = partner_pool.search(
cr, uid, [
('address_error', '=', True),
], context=context)
# ---------------------------------------------------------------------
# Get list of partner problems and return custom tree list
# ---------------------------------------------------------------------
model_pool = self.pool.get('ir.model.data')
view_id = model_pool.get_object_reference(
cr, uid, 'mailing_error', 'view_res_partner_mailing_error')[1]
return {
'type': 'ir.actions.act_window',
'name': _('Mailing error'),
'view_type': 'form',
'view_mode': 'tree,form',
#'res_id': 1,
'res_model': 'res.partner',
'view_id': view_id, # False
'views': [(view_id, 'tree'), (False, 'form')],
'domain': [('id', 'in', partner_error_ids)],
'context': context,
'target': 'current', # 'new'
'nodestroy': False,
}
def prepare_message(email, recipient, recipients_list):
message = email.message
if not message:
return ""
# Parse "Email Account" from "Email Sender"
email_account = get_outgoing_email_account(raise_exception_not_set=False, sender=email.sender)
if frappe.conf.use_ssl and email_account.track_email_status:
# Using SSL => Publically available domain => Email Read Reciept Possible
message = message.replace("<!--email open check-->", quopri.encodestring('<img src="https://{}/api/method/frappe.core.doctype.communication.email.mark_email_as_seen?name={}"/>'.format(frappe.local.site, email.communication).encode()).decode())
else:
# No SSL => No Email Read Reciept
message = message.replace("<!--email open check-->", quopri.encodestring("".encode()).decode())
if email.add_unsubscribe_link and email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
unsubscribe_url = get_unsubcribed_url(email.reference_doctype, email.reference_name, recipient,
email.unsubscribe_method, email.unsubscribe_params)
message = message.replace("<!--unsubscribe url-->", quopri.encodestring(unsubscribe_url.encode()).decode())
if email.expose_recipients == "header":
pass
else:
if email.expose_recipients == "footer":
if isinstance(email.show_as_cc, string_types):
email.show_as_cc = email.show_as_cc.split(",")
email_sent_to = [r.recipient for r in recipients_list]
email_sent_cc = ", ".join([e for e in email_sent_to if e in email.show_as_cc])
email_sent_to = ", ".join([e for e in email_sent_to if e not in email.show_as_cc])
if email_sent_cc:
email_sent_message = _("This email was sent to {0} and copied to {1}").format(email_sent_to,email_sent_cc)
else:
email_sent_message = _("This email was sent to {0}").format(email_sent_to)
message = message.replace("<!--cc message-->", quopri.encodestring(email_sent_message.encode()).decode())
message = message.replace("<!--recipient-->", recipient)
message = (message and message.encode('utf8')) or ''
message = safe_decode(message)
if not email.attachments:
return message
# On-demand attachments
from email.parser import Parser
msg_obj = Parser().parsestr(message)
attachments = json.loads(email.attachments)
for attachment in attachments:
if attachment.get('fcontent'): continue
fid = attachment.get("fid")
if fid:
fname, fcontent = get_file(fid)
attachment.update({
'fname': fname,
'fcontent': fcontent,
'parent': msg_obj
})
attachment.pop("fid", None)
add_attachment(**attachment)
elif attachment.get("print_format_attachment") == 1:
attachment.pop("print_format_attachment", None)
print_format_file = frappe.attach_print(**attachment)
print_format_file.update({"parent": msg_obj})
add_attachment(**print_format_file)
return msg_obj.as_string()
msg = Parser().parsestr(msg_content)
print_info(msg)
file.close()
server.close()
from_addr = email
# to_addr = '*****@*****.**'
to_addr = input('To Email address: ')
smtp_server = 'smtp.163.com'
text = 'Dear' + '\n\n' + u'交大邮件通知,请查收附件。' + '\n\n' + 'best regards' + '\n' + 'Andy Zhang'
msg = MIMEMultipart()
msg['From'] = _format_addr('Andy Zhang <%s>' % from_addr)
msg['To'] = _format_addr('Gmail <%s>' % to_addr)
msg['Subject'] = Header(u'交大邮件通知', 'utf-8')
msg.attach(MIMEText(text, 'plain', 'utf-8'))
with codecs.open('/Users/zhangzhifan/Desktop/mail_log.txt', 'rb', encoding='utf-8') as f:
mime = MIMEText(f.read())
mime.add_header('Content-Disposition', 'attachment', filename='mail_log.txt')
msg.attach(mime)
server = smtplib.SMTP(smtp_server, 25)
server.login(from_addr, password)
server.sendmail(from_addr, [to_addr], msg.as_string())
server.quit()
import glob
import sys
from email.parser import Parser
import smtplib
if __name__ == '__main__':
port = int(sys.argv[1]) if len(sys.argv) > 1 else 2025
smtp = smtplib.SMTP("localhost", port)
for file in glob.glob('spam/*.txt'):
msg = Parser().parse(open(file, 'rb'))
smtp.sendmail('*****@*****.**', ['*****@*****.**'], msg.as_string())
def handler(q=False):
if q is False:
return False
results = []
# Decode and parse email
request = json.loads(q)
# request data is always base 64 byte encoded
data = base64.b64decode(request["data"])
message = message_from_bytes(data)
# Ensure Content-Transfer-Encoding exists, otherwise headers cannot be parsed
if 'Content-Transfer-Encoding' not in message:
message['Content-Transfer-Encoding'] = '8-bit'
# Double decode to force headers to be re-parsed with proper encoding
message = Parser().parsestr(message.as_string())
# FIX: No need to guess encoding, use built in python email class
from email.header import make_header
for key, val in message.items():
replacement = str(make_header(decode_header(val)))
if replacement is not None:
message.replace_header(key, replacement)
# Extract all header information
all_headers = ""
for k, v in message.items():
all_headers += "{0}: {1}\n".format(k.strip(), v.strip())
all_headers = all_headers.replace('\\', '')
results.append({"values": all_headers, "type": 'email-header'})
# E-Mail MIME Boundry
if message.get_boundary():
results.append({"values": message.get_boundary(), "type": 'email-mime-boundary'})
# E-Mail In Reply To
if message.get('In-Reply-To'):
results.append({"values": message.get('In-Reply-To').strip(), "type": 'email-reply-to'})
# NEW: E-Mail Reply To
if message.get('Reply-To'):
results.append({"values": message.get('Reply-To').strip(), "type": 'email-reply-to'})
# X-Mailer
if message.get('X-Mailer'):
results.append({"values": message.get('X-Mailer'), "type": 'email-x-mailer'})
# Thread Index
if message.get('Thread-Index'):
results.append({"values": message.get('Thread-Index'), "type": 'email-thread-index'})
# Email Message ID
if message.get('Message-ID'):
results.append({"values": message.get('Message-ID'), "type": 'email-message-id'})
# Subject
if message.get('Subject'):
subject = re.sub('\r|\n|\t', '', message.get('Subject').strip())
results.append({"values": subject, "type": 'email-subject'})
# Source
source = ''
if message.get('From'):
source = getaddresses(message.get_all('From'))
for address in source:
results.append({"values": address[1], "type": 'email-src', "comment": "From: {0}".format(address)})
results.append({"values": address[0], "type": 'email-src-display-name', "comment": "From: {0}".format(address)})
# Check other source fields
smtp_regex = re.compile(r'smtp\.mailfrom=[^;:]+@[^;:]+(?=[;\s])', re.S) #Old: smtp\.mailfrom=[^;:]+@[^;:]+(?=;)?
smtp_match = re.search(smtp_regex, all_headers)
if smtp_match:
source = smtp_match.group()
results.append({"values": source.replace('smtp.mailfrom=',''), "type": 'email-src', "comment": "{0}".format(source)})
envelope_from_regex = re.compile(r'envelope-from.*?>', re.S)
envelope_from_match = re.search(envelope_from_regex, all_headers)
if envelope_from_match:
source = envelope_from_match.group()
results.append({"values": parseaddr(source)[1], "type": 'email-src', "comment": "{0}".format(source)})
sender_regex = re.compile(r'sender\s.*?>(?=\))', re.S)
sender_match = re.search(sender_regex, all_headers)
if sender_match:
source = sender_match.group()
results.append({"values": parseaddr(source)[1], "type": 'email-src', "comment": "{0}".format(source)})
if message.get('X-Sender'):
source = message.get('X-Sender').strip()
results.append({"values": source, "type": 'email-src', "comment": "X-Sender"})
if message.get('X-Sender-Id'):
source = message.get('X-Sender-Id').strip()
results.append({"values": source, "type": 'email-src', "comment": "X-Sender-Id"})
if message.get('X-Auth-ID'):
source = message.get('X-Auth-ID').strip()
results.append({"values": source, "type": 'email-src', "comment" : "X-Auth-ID"})
# If no source has been identified, try to use Reply To
if not source:
if message.get('Reply-To'):
results.append({"values": parseaddr(message.get('Reply-To').strip())[1], "type": 'email-src', "comment" : "Reply To: {0}".format(message.get('Reply-To'))})
# Return Path
return_path = message.get('Return-Path')
if return_path:
# E-Mail Source
results.append({"values": parseaddr(return_path)[1], "type": 'email-src', "comment": "Return Path: {0}".format(return_path)})
# E-Mail Source Name
results.append({"values": parseaddr(return_path)[0], "type": 'email-src-display-name', "comment": "Return Path: {0}".format(return_path)})
# Destinations
# Split and sort destination header values
recipient_headers = ['To', 'Cc', 'Bcc']
for hdr_val in recipient_headers:
if message.get(hdr_val):
addrs = message.get(hdr_val).split(',')
for addr in addrs:
# Parse and add destination header values
parsed_addr = parseaddr(addr)
results.append({"values": parsed_addr[1], "type": "email-dst", "comment": "{0}: {1}".format(hdr_val, addr)})
results.append({"values": parsed_addr[0], "type": "email-dst-display-name", "comment": "{0}: {1}".format(hdr_val, addr)})
# Get E-Mail Targets
# Get the addresses that received the email.
# As pulled from the Received header
received = message.get_all('Received')
if received:
email_targets = set()
for rec in received:
try:
email_check = re.search("for\s(.*@.*);", rec).group(1)
email_check = email_check.strip(' <>')
email_targets.add(parseaddr(email_check)[1])
except (AttributeError):
continue
for tar in email_targets:
results.append({"values": tar, "type": "target-email", "comment": "Extracted from email 'Received' header"})
# Check if we were given a configuration
config = request.get("config", {})
# Don't be picky about how the user chooses to say yes to these
acceptable_config_yes = ['y', 'yes', 'true', 't']
# Do we unzip attachments we find?
unzip = config.get("unzip_attachments", None)
if (unzip is not None and unzip.lower() in acceptable_config_yes):
unzip = True
# Do we try to find passwords for protected zip files?
zip_pass_crack = config.get("guess_zip_attachment_passwords", None)
if (zip_pass_crack is not None and zip_pass_crack.lower() in acceptable_config_yes):
zip_pass_crack = True
password_list = None # Only want to collect password list once
# Do we extract URL's from the email.
extract_urls = config.get("extract_urls", None)
if (extract_urls is not None and extract_urls.lower() in acceptable_config_yes):
extract_urls = True
# Get Attachments
# Get file names of attachments
for part in message.walk():
# FIX: Skip container
if part.is_multipart():
continue
# FIX: Look for attachment in 'content-disposition' header as 'filename', otherwise check 'name' parameter of 'content-type' header
filename = part.get_param('filename', None, 'content-disposition')
if not filename:
filename=part.get_param('name', None)
if filename is not None:
# FIX: decode any encoded attachment names -- decode header returns a tuple [(text, encoding), ...]
if decode_header(filename)[0][1] is not None:
filename = str(decode_header(filename)[0][0].decode(decode_header(filename)[0][1]))
filename = re.sub('\r|\n|\t', '', filename.strip())
results.append({"values": filename, "type": 'email-attachment'})
attachment_data = part.get_payload(decode=True)
# Base attachment data is default
attachment_files = [{"values": filename, "data": base64.b64encode(attachment_data).decode()}]
if unzip is True: # Attempt to unzip the attachment and return its files
zipped_files = ["doc", "docx", "dot", "dotx", "xls",
"xlsx", "xlm", "xla", "xlc", "xlt",
"xltx", "xlw", "ppt", "pptx", "pps",
"ppsx", "pot", "potx", "potx", "sldx",
"odt", "ods", "odp", "odg", "odf",
"fodt", "fods", "fodp", "fodg", "ott",
"uot"]
zipped_filetype = False
for ext in zipped_files:
if filename.endswith(ext) is True:
zipped_filetype = True
if zipped_filetype == False:
try:
attachment_files += get_zipped_contents(filename, attachment_data)
except RuntimeError: # File is encrypted with a password
if zip_pass_crack is True:
if password_list is None:
password_list = get_zip_passwords(message)
password = test_zip_passwords(attachment_data, password_list)
if password is None: # Inform the analyst that we could not crack password
attachment_files[0]['comment'] = "Encrypted Zip: Password could not be cracked from message"
else:
attachment_files[0]['comment'] = """Original Zipped Attachment with Password {0}""".format(password)
attachment_files += get_zipped_contents(filename, attachment_data, password=password)
except zipfile.BadZipFile: # Attachment is not a zipfile
pass
for attch_item in attachment_files:
attch_item["type"] = 'malware-sample'
results.append(attch_item)
# FIX: Pull this out of the else statement -- Check email body part for urls
if extract_urls is True:
charset = get_charset(part, get_charset(message))
urls_unique = []
if part.get_content_type() == 'text/html':
url_parser = HTMLURLParser()
# FIX: Account for different encoding types in the email body
decoded_part = part.get_payload(decode=True).decode(charset, errors='ignore')
# Decode Quoted-Printable
if part.__getitem__('Content-Transer-Encoding') == 'quoted-printable':
import quopri
decoded_part = quopri.decodestring(part.get_payload(decode=True).decode(charset, errors='ignore'))
# Decode Base64
elif part.__getitem__('Content-Transer-Encoding') == 'base64':
decoded_part = base64.b64decode(part.get_payload(decode=True).decode(charset, errors='ignore'))
# Parse URLs
url_parser.feed(decoded_part)
urls = url_parser.urls
for url in urls:
# FIX: Sometimes url values are 'None' -- skip these
if url and url not in urls_unique:
urls_unique.append(url)
# FIX: Parse urls not contained in text/html
elif part.get_content_type() == 'text/plain':
decoded_part = part.get_payload(decode=True).decode(charset, errors='ignore')
url_regex = re.compile(r"((http|ftp|mailto|telnet|ssh)(s){0,1}\:\/\/[\w|\/|\.|\#|\?|\&|\=|\-|\%]+)+", re.VERBOSE | re.MULTILINE)
for match in url_regex.findall(decoded_part):
url = match[0]
if url not in urls_unique:
urls_unique.append(url)
# FIX: Append unique urls to results if extract_urls config was set to True
if extract_urls is True:
url_scheme_pattern = r'^(http|ftp|mailto|telnet|ssh|tel)(s){0,1}\:.*'
url_scheme_regex = re.compile(url_scheme_pattern, re.I)
# For each URL ensure a path was provided; exclude URLs equal to pound sign
for url in urls_unique:
if '#' not in url and 'mailto' not in url:
url_scheme_match = re.search(url_scheme_regex, url)
# Due to a bug with urlparse adding an extra escape for scheme, http:///, scheme must be hardcoded prior to parsing
if not url_scheme_match:
url = 'http://'+url
# Parse pattern in traffic based on path component returned from urlparse; exclude when path is empty or equal to '/'
results.append({"values": url, "type": 'url'})
parsed = urlparse(url)
if parsed.path and parsed.path != '/':
results.append({"values": parsed.path, "type": 'pattern-in-traffic'})
r = {'results': results}
return r
# Import the email modules we'll need
from email.mime.text import MIMEText
textfile = '/tmp/mail.txt'
me = '"UPC" <*****@*****.**>'
you = '*****@*****.**'
# Open a plain text file for reading. For this example, assume that
# the text file contains only ASCII characters.
message = Parser().parse(open(textfile, 'r'))
# fp = open(textfile, 'rb')
# # Create a text/plain message
# msg = MIMEText(fp.read())
# fp.close()
# # me == the sender's email address
# # you == the recipient's email address
# msg['Subject'] = 'The contents of %s' % textfile
# msg['From'] = me
# msg['To'] = you
# print msg.as_string()
# quit()
# Send the message via our own SMTP server, but don't include the
# envelope header.
s = smtplib.SMTP('localhost', 10025)
s.sendmail(me, [you], message.as_string())
s.quit()
if tanNrReminder >= tansReminderLength:
print '\n\n(i) sent mails for all entries in ' + tanFileReminder
break
print '(i) processing TAN ' + tans[tanNr].rstrip() + ', looking for ' + tansReminder[tanNrReminder].rstrip()
if tans[tanNr] != tansReminder[tanNrReminder]:
tanNr += 1
continue
# To-Feld in Mailheader einfügen
mail.__delitem__('To')
mail['To'] = line.rstrip()
try:
print '(i) preparing and sending mail to: ' + mail['To'] + ' with TAN ' + tans[tanNr].rstrip()
mail.set_payload(mail.get_payload().replace(tans[tanNrLastSent], tans[tanNr]))
tanNrLastSent = tanNr
s.sendmail(mail['From'], line, mail.as_string())
# Fehlerbehandlung
except smtplib.SMTPRecipientsRefused:
print '\nERROR on sending mail to:' + line.rstrip() +'\n'
sys.exit(2)
mailCount += 1
print '(i) ... sent! (line ' + str(tanNr+1) + ' in ' + addressFile + ')'
# damit wurde eine Mail versendet, also Zähler erhöhen
tanNr += 1
tanNrReminder += 1
# Ende
host = config.get("Database","host"))
cur = conn.cursor()
if config.get("Mailserver","ssl") == "true":
print "SSL"
mailserver = smtplib.SMTP_SSL(config.get("Mailserver","host"),config.get("Mailserver","port"))
else:
print "Not-SSL"
mailserver = smtplib.SMTP(config.get("Mailserver","host"),config.get("Mailserver","port"))
print "Read Standard in now!"
email = Parser().parse(sys.stdin)
print "End of standard in!"
# Main Body!
cur.execute('SELECT customer_number, customer_name, correspond_contact_email, correspond_contact_first FROM api.customer WHERE customer_type = %s', (options.cust_type, ))
custlist = cur.fetchall()
for cust in custlist:
(cust_number, cust_name, contact_email, contact_first) = cust
print cust
email.replace_header('To', contact_email)
mytemplate = Template(email.as_string())
print mytemplate.render(cust_name=cust_name, contact_email=contact_email, contact_first=contact_first)
# mailserver.sendmail(email['From'],email['To'], email.as_string())
# Clean everything up!
mailserver.quit()
cur.close()
conn.close()
def execute(*args, **kw):
if not os.path.isdir(mybasepath):
os.makedirs(mybasepath)
for stage in ['incoming', 'ACCEPT']:
if not os.path.isdir(os.path.join(mybasepath, stage)):
os.makedirs(os.path.join(mybasepath, stage))
# TODO: Test for correct call.
filepath = args[0]
if kw.has_key('stage'):
log.debug(_("Issuing callback after processing to stage %s") %
(kw['stage']),
level=8)
log.debug(_("Testing cb_action_%s()") % (kw['stage']), level=8)
if hasattr(modules, 'cb_action_%s' % (kw['stage'])):
log.debug(_("Attempting to execute cb_action_%s()") %
(kw['stage']),
level=8)
exec('modules.cb_action_%s(%r, %r)' %
(kw['stage'], 'gpgencrypt', filepath))
log.debug(_("Executing module gpgencrypt for %r, %r") % (args, kw),
level=8)
new_filepath = os.path.join(
'/var/spool/pykolab/wallace/gpgencrypt/incoming',
os.path.basename(filepath))
if not filepath == new_filepath:
log.debug("Renaming %r to %r" % (filepath, new_filepath))
os.rename(filepath, new_filepath)
filepath = new_filepath
# parse message headers
# @TODO: make sure we can use True as the 2nd argument here
message = Parser().parse(open(filepath, 'r'), True)
# Possible gpgencrypt answers are limited to ACCEPT only
answers = ['ACCEPT']
# from Mail::GnuPG.is_encrypted
#
#sub is_encrypted {
# my ($self,$entity) = @_;
# return 1
# if (($entity->effective_type =~ m!multipart/encrypted!)
# ||
# ($entity->as_string =~ m!^-----BEGIN PGP MESSAGE-----!m));
# return 0;
#}
message_already_encrypted = False
for part in message.walk():
if part.get_content_type() in ["application/pgp-encrypted"]:
message_already_encrypted = True
log.debug(
_("Message is already encrypted (app/pgp-enc content-type)"),
level=8)
if message.get_content_type() in ["multipart/encrypted"]:
message_already_encrypted = True
log.debug(_("Message already encrypted by main content-type header"),
level=8)
if message_already_encrypted:
return filepath
try:
# What are recipient addresses to encrypt to (bitmask)?
# 1 - organization key
# 2 - envelope to
# 4 - to
# 8 - cc
# 16 - resent-to
# 32 - resent-cc
encrypt_to_rcpts = conf.get('wallace', 'gpgencrypt_to_rcpts')
if encrypt_to_rcpts == None:
encrypt_to_rcpts = 14
else:
encrypt_to_rcpts = (int)(encrypt_to_rcpts)
# Only encrypt to keys that are trusted
strict_crypt = conf.get('wallace', 'gpgencrypt_strict')
if strict_crypt == None:
strict_crypt = False
# Organization key ID
if encrypt_to_rcpts & 1:
encrypt_to_org = conf.get('wallace', 'gpgencrypt_to_org_key')
if encrypt_to_org == None and encrypt_to_rcpts & 1:
if strict_crypt:
log.error(
_("Configured to encrypt to a key not configured, and strict policy enabled. Bailing out."
))
modules.cb_action_REJECT('gpgencrypt', filepath)
else:
log.error(
_("Configured to encrypt to a key not configured, but continuing anyway (see 'gpgencrypt_strict')."
))
else:
encrypt_to_org = []
# Bounce the message if encryption fails?
force_crypt = conf.get('wallace', 'gpgencrypt_force')
if force_crypt == None:
force_crypt = False
# Retrieve keys from remote server(s) automatically?
retrieve_keys = conf.get('wallace', 'gpgencrypt_retrieve_keys')
if retrieve_keys == None:
retrieve_keys = False
if retrieve_keys:
gpgserver = conf.get('wallace', 'gpgencrypt_server')
if gpgserver == None:
gpgserver = 'pgp.mit.edu'
encrypt_to = []
if encrypt_to_rcpts & 2:
encrypt_to.extend(message.get_all('X-Kolab-To', []))
if encrypt_to_rcpts & 4:
encrypt_to.extend(message.get_all('to', []))
if encrypt_to_rcpts & 8:
encrypt_to.extend(message.get_all('cc', []))
if encrypt_to_rcpts & 16:
encrypt_to.extend(message.get_all('resent-to', []))
if encrypt_to_rcpts & 32:
encrypt_to.extend(message.get_all('resent-cc', []))
recipients = [
address for displayname, address in getaddresses(encrypt_to)
]
log.debug(_("Recipients: %r") % (recipients))
# Split between recipients we can encrypt for/to, and ones we can not
encrypt_rcpts = []
nocrypt_rcpts = []
gpg = gnupg.GPG(gnupghome='/var/lib/kolab/.gnupg',
verbose=conf.debuglevel > 8)
gpg.encoding = 'utf-8'
local_keys = gpg.list_keys()
log.debug(_("Current keys: %r") % (local_keys), level=8)
for recipient in recipients:
key_local = False
log.debug(_("Retrieving key for recipient: %r") % (recipient))
for key in local_keys:
for address in [
x for x in [
address for displayname, address in getaddresses(
key['uids'])
] if x == recipient
]:
log.debug(_("Found matching address %r") % (address))
key_local = key['keyid']
if key_local == False:
if retrieve_keys:
remote_keys = gpg.search_keys(recipient, gpgserver)
if len(remote_keys) == 1:
for address in [
x for x in [
address for displayname, address in
getaddresses(remote_keys[0]['uids'])
] if x == recipient
]:
log.debug(
_("Found matching address %r in remote keys") %
(address))
gpg.recv_keys(gpgserver, remote_keys[0]['keyid'])
local_keys = gpg.list_keys()
else:
nocrypt_rcpts.append(recipient)
for key in local_keys:
for address in [
x for x in [
address for displayname, address in getaddresses(
key['uids'])
] if x == recipient
]:
log.debug(_("Found matching address %r") % (address))
key_local = key['keyid']
if not key_local == False:
encrypt_rcpts.append(key_local)
payload = message.get_payload()
#print "payload:", payload
if len(encrypt_rcpts) < 1:
return filepath
if "multipart" in message.get_content_type():
log.debug(_(
"Mime Message - we need to build multipart/encrypted structure"
),
level=8)
msg = message
enc_mime_message = pgp_mime(msg, encrypt_rcpts)
message = enc_mime_message
else:
log.debug(_("No Mime Message - encypt plain"), level=8)
encrypted_data = gpg.encrypt(payload,
encrypt_rcpts,
always_trust=True)
encrypted_string = str(encrypted_data)
message.set_payload(encrypted_string)
message.add_header('X-wallace-gpg-encrypted', 'true')
(fp, new_filepath) = tempfile.mkstemp(
dir="/var/spool/pykolab/wallace/gpgencrypt/ACCEPT")
os.write(fp, message.as_string())
os.close(fp)
os.unlink(filepath)
exec('modules.cb_action_%s(%r, %r)' %
('ACCEPT', 'gpgencrypt', new_filepath))
except Exception, errmsg:
log.error(_("An error occurred: %r") % (errmsg))
if conf.debuglevel > 8:
import traceback
traceback.print_exc()
def processMailFile(fileName):
# Open mail
mainMsg = Parser().parse(open(fileName))
try:
debug(1, "Processing message with Message-ID {}".format(mainMsg['Message-ID']))
except ValueError:
debug(1, "Processing message with unknown Message-ID")
########################################################################
# If mail message isn't already multipart, i.e. MIME, message then
# we don't do anything with it...
########################################################################
if not mainMsg.is_multipart():
debug(2, "Not a multipart message. Skipping.")
return
########################################################################
# Create a lists of senders and recepients!
########################################################################
fromStr = mainMsg['From']
debug(4, "FROM string: {0}".format(fromStr))
fromList = []
if fromStr:
fromList = re.findall('<[^ <]+@[^ >,]+>', fromStr)
if fromList == []:
fromList = re.findall('[^ <]+@[^ >,]+', fromStr)
debug(3, "Discovered sender: {0}".format(str(fromList)))
toStr = mainMsg['To']
debug(4, "TO string: {0}".format(toStr))
toList = []
if toStr:
toList = re.findall('<[^ <]+@[^ >,]+>', toStr)
if toList == []:
toList = re.findall('[^ <]+@[^ >,]+', toStr)
ccStr = mainMsg['Cc']
debug(4, "CC string: {0}".format(ccStr))
ccList = []
if ccStr:
ccList = re.findall('<[^ <]+@[^ >,]+>', ccStr)
if ccList == []:
ccList = re.findall('[^ <]+@[^ >,]+', ccStr)
toList.extend(ccList)
debug(3, "Discovered recipients: {0}".format(str(toList)))
########################################################################
# Check if this is an internal mail. If so, don't do anything
# with a message
########################################################################
try:
for mailAddress in toList:
mailAddress.index(MY_DOMAIN)
debug(1, "Internal mail message. Skipping.")
return
except ValueError:
debug(1, "Found external mail address.")
########################################################################
# Check blacklisted sender. If there is one, just skip further
# processing
########################################################################
for mailAddress in toList:
for b in SENDER_BLACK_LIST:
try:
mailAddress.index(b)
debug(3, "In From header field found sender {} from the black list".format(b))
debug(2, "Sender in the black list. Stopping.")
return
except ValueError:
pass
########################################################################
# Check white list
########################################################################
if len(SENDER_WHITE_LIST):
white_found = False
for mailAddress in toList:
for w in SENDER_WHITE_LIST:
try:
mailAddress.index(w)
white_found = True
debug(3, "In From header field found sender {} from the white list".format(w))
break
except ValueError:
pass
if white_found:
break
if not white_found:
debug(2, "White list specified without sender of the current message in the list. Stopping.")
return
########################################################################
# Check blacklisted receiver. If there is one, just skip further
# processing
########################################################################
for mailAddress in toList:
for b in RECEIVER_BLACK_LIST:
try:
mailAddress.index(b)
debug(3, "In From header field found receiver {} from the black list".format(b))
debug(2, "Receiver in the black list. Stopping.")
return
except ValueError:
pass
########################################################################
# Check if attachment is already there. If so, don't
# do anything with it, only replace it with newer version
########################################################################
debug(2, "Checking if attachment already exists")
found, changed, newPayload = checkSubparts(mainMsg)
if found:
if changed:
mainMsg.set_payload(newPayload)
open(fileName, 'w').write(mainMsg.as_string())
return
########################################################################
# No attachment so recreate a message
########################################################################
debug(3, "No existing attachment version, recreating message to include one")
replaced = processMultipartMessage(mainMsg)
########################################################################
# Finally, add the message to the mail, and save new version of the
# mail message
########################################################################
if not DRY_RUN:
if replaced:
debug(2, "Inserting image into mail message.")
open(fileName, 'w').write(mainMsg.as_string())
else:
debug(3, "Probably old disclaimer without image reference. No image attached!")
else:
debug(1, "Dry run specified. Message wasn't changed!")
incoming = Parser().parse(sys.stdin, True)
frm = incoming['From']
name, addr = parseaddr(frm)
if addr.lower() != cfg['main']['notify'].lower():
# Received a message from unrecognized email
from modules import smtp
mailer = smtp.Mailer(cfg)
subject = 'Unauthorized Usage'
body = 'An email has been received from unauthorized email address: <%s>\n\n' % addr
body += 'Complete original email follows:\n\n'
body += incoming.as_string(True)
mailer.send_email(subject, body)
sys.exit(0)
# Extract phone number to send SMS to
subject = incoming['Subject']
match = SUBJECT_REGEX.search(subject)
if not match:
# Try one more time, this time searching "To" header.
to = incoming['To']
name, addr = parseaddr(to)
#Import the email modules we'll need
from email.parser import Parser
import os
import sys
rootdir = sys.argv[1]
print "Date,Name,Phone,Email"
with open('fboutput.csv','w') as fo:
for rootdir, subFolders, files in os.walk(rootdir):
for file in files:
filePath = rootdir + '/' + file
f = open( filePath, 'r')
headers = Parser().parse(f)
body = headers.as_string()
lines = body.split("\n")
for index, line in enumerate(lines):
# if "Online:" in line:
# print lines[index+1]
# fo.write(lines[index+1]+",")
# continue
if "----------------" in line:
print lines[index+2]
fo.write(lines[index+2]+",")
continue
if "Name:" in line:
print line
fo.write(line+",")
continue
elif "Email:" in line:
def prepare_message(email, recipient, recipients_list):
message = email.message
if not message:
return ""
# Parse "Email Account" from "Email Sender"
email_account = get_outgoing_email_account(raise_exception_not_set=False,
sender=email.sender)
if frappe.conf.use_ssl and email_account.track_email_status:
# Using SSL => Publically available domain => Email Read Reciept Possible
message = message.replace(
"<!--email open check-->",
quopri.encodestring(
'<img src="https://{}/api/method/frappe.core.doctype.communication.email.mark_email_as_seen?name={}"/>'
.format(frappe.local.site,
email.communication).encode()).decode())
else:
# No SSL => No Email Read Reciept
message = message.replace("<!--email open check-->",
quopri.encodestring("".encode()).decode())
if email.add_unsubscribe_link and email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
unsubscribe_url = get_unsubcribed_url(email.reference_doctype,
email.reference_name, recipient,
email.unsubscribe_method,
email.unsubscribe_params)
message = message.replace(
"<!--unsubscribe url-->",
quopri.encodestring(unsubscribe_url.encode()).decode())
if email.expose_recipients == "header":
pass
else:
if email.expose_recipients == "footer":
if isinstance(email.show_as_cc, string_types):
email.show_as_cc = email.show_as_cc.split(",")
email_sent_to = [r.recipient for r in recipients_list]
email_sent_cc = ", ".join(
[e for e in email_sent_to if e in email.show_as_cc])
email_sent_to = ", ".join(
[e for e in email_sent_to if e not in email.show_as_cc])
if email_sent_cc:
email_sent_message = _(
"This email was sent to {0} and copied to {1}").format(
email_sent_to, email_sent_cc)
else:
email_sent_message = _("This email was sent to {0}").format(
email_sent_to)
message = message.replace(
"<!--cc message-->",
quopri.encodestring(email_sent_message.encode()).decode())
message = message.replace("<!--recipient-->", recipient)
message = (message and message.encode('utf8')) or ''
message = safe_decode(message)
if PY3:
from email.policy import SMTPUTF8
message = Parser(policy=SMTPUTF8).parsestr(message)
else:
message = Parser().parsestr(message)
if email.attachments:
# On-demand attachments
attachments = json.loads(email.attachments)
for attachment in attachments:
if attachment.get('fcontent'):
continue
fid = attachment.get("fid")
if fid:
_file = frappe.get_doc("File", fid)
fcontent = _file.get_content()
attachment.update({
'fname': _file.file_name,
'fcontent': fcontent,
'parent': message
})
attachment.pop("fid", None)
add_attachment(**attachment)
elif attachment.get("print_format_attachment") == 1:
attachment.pop("print_format_attachment", None)
print_format_file = frappe.attach_print(**attachment)
print_format_file.update({"parent": message})
add_attachment(**print_format_file)
return safe_encode(message.as_string())
def import_mail_problem_address(self, cr, uid, ids, context=None):
''' Check error message folder and parse name for check error in
partner mail address
'''
# Utility:
def clean(all_mail, mail_sent):
''' Remove not necessary mail
'''
res = []
for email in all_mail:
if email in mail_sent and email not in res:
res.append(email)
return res
partner_pool = self.pool.get('res.partner')
# Read base folder for mailing
error_path = self.pool.get('res.company').get_base_local_folder(
cr, uid, subfolder='mailing_error', context=context)
error_path = os.path.expanduser(error_path)
# Read 2 subfolder for mailing:
mail_path = os.path.join(error_path, 'mail')
csv_path = os.path.join(error_path, 'csv')
# Create if not existe 2 subfolder paths
os.system('mkdir -p %s' % mail_path)
os.system('mkdir -p %s' % csv_path)
# ---------------------------------------------------------------------
# Read all mail in newsletter
# ---------------------------------------------------------------------
file_mail = os.path.join(csv_path, 'mail.csv')
mail_sent = {}
for address in open(file_mail, 'r'):
address = address.strip()
partner_ids = partner_pool.search(cr, uid, [
('email', '=', address),
], context=context)
# TODO test partner not present
mail_sent[address] = partner_ids
# ---------------------------------------------------------------------
# Read all mail in error mail folder
# ---------------------------------------------------------------------
for mail_file in [f for f in os.listdir(mail_path)]:
mail_fullfile = os.path.join(mail_path, mail_file)
message = Parser().parse(open(mail_fullfile, 'r'))
# Parse message parameters:
subject = message['subject'].replace('\n','').replace('\r','')
mail_to = message['to']
mail_from = message['from']
# Extract list of mail address in mail text file:
all_mail = clean(
re.findall(r'[\w\.-]+@[\w\.-]+', message.as_string()),
mail_sent,
)
for mail_found in all_mail:
partner_error_ids = mail_sent.get(mail_found, False)
if partner_error_ids:
partner_pool.write(cr, uid, partner_error_ids, {
'address_error': True,
'address_error_text': 'Subject: %s\nFrom: %s To: %s' % (
subject,
mail_from,
mail_to,
)
}, context=context)
# TODO delete file after update res.partner
# Extract mail:
#try:
# mail_address = mail.split('<')[1].split('>')[0]
#except:
# mail_address = mail
# ---------------------------------------------------------------------
# Search customer mail for mark problem
# ---------------------------------------------------------------------
partner_error_ids = partner_pool.search(cr, uid, [
('address_error', '=', True),
], context=context)
# ---------------------------------------------------------------------
# Get list of partner problems and return custom tree list
# ---------------------------------------------------------------------
model_pool = self.pool.get('ir.model.data')
view_id = model_pool.get_object_reference(cr, uid,
'mailing_error', 'view_res_partner_mailing_error')[1]
return {
'type': 'ir.actions.act_window',
'name': _('Mailing error'),
'view_type': 'form',
'view_mode': 'tree,form',
#'res_id': 1,
'res_model': 'res.partner',
'view_id': view_id, # False
'views': [(view_id, 'tree'), (False, 'form')],
'domain': [('id', 'in', partner_error_ids)],
'context': context,
'target': 'current', # 'new'
'nodestroy': False,
}