def recv_mail(self):
if not self.downloader:
slog.warning("downloader not login")
return False
self.downloader.select() # Select inbox or default namespace
(retcode, messages) = self.downloader.search(None, '(UNSEEN)')
if retcode != 'OK':
slog.warning("read mail from server failed")
return False
if not os.path.exists("./downmail"):
os.mkdir("./downmail")
for num in messages[0].split():
slog.info('Processing: {0}'.format(num))
typ, data = self.downloader.fetch(num.decode('utf-8'), '(RFC822)')
# 标记已读
sr = self.downloader.store(num, '+FLAGS', '\Seen')
# 标记删除
#sr = downloader.store(num, '+FLAGS', '\\Deleted')
email_message = email.message_from_string(
data[0][1].decode('utf-8'))
# mail to string
fp = StringIO()
g = generator.Generator(fp, mangle_from_=True, maxheaderlen=60)
g.flatten(email_message)
email_text = fp.getvalue()
# mail_string to json_string
pmail = mailparser.parse_from_string(email_text)
email_json = pmail.mail_json
# mail to json obj
email_data = json.loads(email_json)
# 处理邮件
self.handle_mail(email_data)
subject = email_data.get('subject')
body = email_data.get('body')
slog.info("get mail: subject[{0}] body.size[{1}]".format(
subject, len(body)))
filename = './downmail/{0}.eml'.format(subject)
with open(filename, 'w') as fout:
gr = generator.Generator(fout)
gr.flatten(email_message)
#fout.write(email_text)
fout.close()
filename_j = './downmail/{0}.json'.format(subject)
with open(filename_j, 'w') as fjout:
fjout.write(
json.dumps(email_data, indent=4, ensure_ascii=False))
fjout.close()
slog.info("save {0} ok,\n".format(filename))
return True
def handle(self, *args, **options):
raw_mail = options.get('message').read()
from mailparser import parse_from_string
mail = parse_from_string(raw_mail)
To = mail.to
try:
ml = List.objects.get(email=To)
except List.DoesNotExist:
raise CommandError('No mailing list by this name "%s"' % To)
From = str(mail.from_)
Subject = str(mail.subject)
Body = str(mail.body)
Attachments = mail.attachments
ok = send_email(To, From, Subject, Body, Attachemnts)
if ok:
self.stdout.write(
self.style.SUCCESS('Successfully send message to "%s"' %
list_email))
else:
self.stdout.write(
self.style.DANGER('Error in sending message to "%s"' %
list_email))
def _run_action(self, action_parameters):
"""
Run action with the provided action parameters, return status output and
parse the output email data.
"""
models = self.fixtures_loader.load_models(
fixtures_pack='packs/core',
fixtures_dict={'actions': ['sendmail.yaml']})
action_db = models['actions']['sendmail.yaml']
entry_point = self.fixtures_loader.get_fixture_file_path_abs(
'packs/core', 'actions', 'send_mail/send_mail')
runner = self._get_runner(action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run(action_parameters)
runner.post_run(status, result)
# Remove footer added by the action which is not part of raw email data and parse
# the message
if 'stdout' in result:
email_data = result['stdout']
email_data = email_data.split('\n')[:-2]
email_data = '\n'.join(email_data)
if six.PY2 and isinstance(email_data, six.text_type):
email_data = email_data.encode('utf-8')
message = mailparser.parse_from_string(email_data)
else:
email_data = None
message = None
return (status, result, email_data, message)
def attach(email_id, file_name):
try:
conn = sqlite3.connect(DB)
cur = conn.cursor()
sql = f"""
select email_raw from {TABLE} where id={email_id}
"""
cur.execute(sql)
val = cur.fetchone()
cur.close()
conn.close()
raw_email = val[0]
mail = mailparser.parse_from_string(raw_email)
data = ""
charset = "utf-8"
for att in mail.attachments:
fnm =att['filename']
if fnm==file_name:
data = att['payload']
charset = "utf-8" if att['charset'] is None else att['charset']
data = base64.b64decode(data)
response = make_response(data)
mime_type = mimetypes.guess_type(file_name)[0]
response.headers['Content-Type'] = mime_type
response.headers['Content-Disposition'] = f'attachment; "filename*=UTF-8 {quote(file_name.encode("utf-8"))}'
return response
except Exception as err:
print(err)
abort(404)
def parse_from_email(self, content):
"""
Parse a raw email
:param str content: The raw email
:rtype: `cerberus.parsers.ParsedEmail`
:return: The parsed email
"""
email = mailparser.parse_from_string(content)
provider = self._get_provider(email)
recipients = "{} {}".format(" ".join([addr for _, addr in email.to_]),
email.message.get("Cc"))
parsed = ParsedEmail(
headers=email.headers,
subject=email.subject.strip().rstrip("\x00"),
body=email.body.strip().rstrip("\x00"),
date=int(time.mktime(utc2local(email.date).timetuple())),
provider=provider,
recipients=self.email_re.findall(recipients),
attachments=decode_attachments(email.attachments),
blacklisted=provider in self.blacklisted_providers,
)
# Add 'message/*' content to body
parsed.body = "{}\n\n--- Forwarded email(s) ---\n{}".format(
parsed.body,
"\n\n--------".join(get_mime_message_type_contents(email.message)),
)
self._fetch_items(parsed)
self._force_abuse_category(parsed)
parsed.clean_items()
return parsed
def _run_action(self, action_parameters):
"""
Run action with the provided action parameters, return status output and
parse the output email data.
"""
models = self.fixtures_loader.load_models(
fixtures_pack='packs/core', fixtures_dict={'actions': ['sendmail.yaml']})
action_db = models['actions']['sendmail.yaml']
entry_point = self.fixtures_loader.get_fixture_file_path_abs(
'packs/core', 'actions', 'send_mail/send_mail')
runner = self._get_runner(action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run(action_parameters)
runner.post_run(status, result)
# Remove footer added by the action which is not part of raw email data and parse
# the message
if 'stdout' in result:
email_data = result['stdout']
email_data = email_data.split('\n')[:-2]
email_data = '\n'.join(email_data)
if six.PY2 and isinstance(email_data, six.text_type):
email_data = email_data.encode('utf-8')
message = mailparser.parse_from_string(email_data)
else:
email_data = None
message = None
return (status, result, email_data, message)
def _run_action(self, action_parameters):
"""
Run action with the provided action parameters, return status output and
parse the output email data.
"""
models = self.fixtures_loader.load_models(
fixtures_pack="packs/core",
fixtures_dict={"actions": ["sendmail.yaml"]})
action_db = models["actions"]["sendmail.yaml"]
entry_point = self.fixtures_loader.get_fixture_file_path_abs(
"packs/core", "actions", "send_mail/send_mail")
runner = self._get_runner(action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run(action_parameters)
runner.post_run(status, result)
# Remove footer added by the action which is not part of raw email data and parse
# the message
if "stdout" in result:
email_data = result["stdout"]
email_data = email_data.split("\n")[:-2]
email_data = "\n".join(email_data)
if six.PY2 and isinstance(email_data, six.text_type):
email_data = email_data.encode("utf-8")
message = mailparser.parse_from_string(email_data)
else:
email_data = None
message = None
return (status, result, email_data, message)
def detail(id, type):
"""
:param id:
:param type:
:return:
"""
conn = sqlite3.connect(DB)
cur = conn.cursor()
sql = f"""
select id, dt, email_raw from {TABLE} where id={id}
"""
cur.execute(sql)
val = cur.fetchone()
cur.close()
conn.close()
raw_email = val[2]
mail = mailparser.parse_from_string(raw_email)
if type=='html':
mail_content = mail.text_html
else:
mail_content = mail.text_plain
from_ = mail.from_[0][1]
to_ = mail.to[0][1]
dt = val[1]
email_subject = mail.subject
return render_template("detail.html", **{"title":email_subject, "from":from_, "type":type, "to":to_, "dt":dt, "mail_content":mail_content,
"attachements":mail.attachments, "mid":id
})
def email(email):
"""
获得时间最近的一个email
:param email:
:param type:
:return:
"""
conn = sqlite3.connect(DB)
cur = conn.cursor()
sql = f"""
select id,dt,email_raw from {TABLE} where email_to=? order by dt desc limit 1;
"""
cur.execute(sql, [email])
val = cur.fetchone()
cur.close()
conn.close()
raw_email = val[2]
mail = mailparser.parse_from_string(raw_email)
result = {}
result['id'] = val[0]
result['from'] = mail.from_[0][1]
result['to_'] = mail.to[0][1]
result['title'] = mail.subject
result['dt'] = val[1]
result['html'] = mail.text_html
result['text'] = mail.text_plain
return jsonify(result)
def tarnsforming_raw_text(self):
# Import the email modules we'll need
import glob
import email
import mailparser
from email import policy
from email.parser import BytesParser
path = 'C:/Users/Lokesh/jupyter works/email_classification/datawe/raw/Email_Classification/*'
email_types = glob.glob(path)
self.appendFilesData = []
for folder in email_types:
files = glob.glob(folder + "/*.txt")
email_type = folder.split('\\')[1]
for name in files:
try:
with open(name) as fp:
raw_data = fp.read()
# file_raw_data.append(raw_data)
msg = mailparser.parse_from_string(raw_data)
self.appendFilesData.append({
"to": msg.to,
"from": msg.from_,
"subject": msg.subject,
"date": msg.date,
# "sent":msg["Sent"],
# "importance":msg["Importance"],
"content": raw_data,
"class_to_exec": email_type,
})
except IOError as exc:
print('Exception')
return self.appendFilesData
def parseThis(fullfilename):
myStream = openEr(fullfilename)
email_message = mailparser.parse_from_string(myStream)
global _mdate
_mdate = email_message.date
_body = email_message.body
_id = email_message.message_id
return _body
async def parse(self, from_,to_, raw_mail):
mail = mailparser.parse_from_string(raw_mail)
email_subject = mail.subject
has_attach = 1 if len(mail.attachments)>0 else 0
tm = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"{tm}\t{from_}\t{to_}\t{email_subject}")
for ito_ in to_:
await self.save_mail(from_, ito_, email_subject, tm, raw_mail, has_attach)
def main():
args = get_args().parse_args()
if args.file:
if args.outlook:
parser = mailparser.parse_from_file_msg(args.file)
else:
parser = mailparser.parse_from_file(args.file)
elif args.string:
parser = mailparser.parse_from_string(args.string)
elif args.stdin:
if args.outlook:
raise MailParserOutlookError(
"You can't use stdin with msg Outlook")
parser = mailparser.parse_from_file_obj(sys.stdin)
if args.json:
safe_print(parser.mail_json)
if args.body:
safe_print(parser.body)
if args.headers:
safe_print(parser.headers_json)
if args.to:
safe_print(parser.to_json)
if args.delivered_to:
safe_print(parser.delivered_to_json)
if args.from_:
safe_print(parser.from_json)
if args.subject:
safe_print(parser.subject)
if args.receiveds:
safe_print(parser.received_json)
if args.defects:
for i in parser.defects_categories:
safe_print(i)
if args.senderip:
r = parser.get_server_ipaddress(args.senderip)
if r:
safe_print(r)
else:
safe_print("Not Found")
if args.attachments or args.attachments_hash:
print_attachments(parser.attachments, args.attachments_hash)
if args.mail_hash:
print_mail_fingerprints(parser.body.encode("utf-8"))
def from_string(cls, raw_email, key):
mail = mailparser.parse_from_string(raw_email)
data = {
'id': key,
'title': mail.subject,
'from_email': mail._from,
'body_html': mail.body,
'body_plain': mail.body,
'media': [],
'date': mail.date,
}
for i, att in enumerate(mail.attachments):
# Ensure unique objectKeys for attachments
filename = '{}-{}-{}'.format(key, i, att['filename'])
response = s3client.put_object(
ACL='public-read',
Body=base64.b64decode(att['payload']),
Bucket=bucket_name,
ContentType=att['mail_content_type'],
Key=filename,
)
location = s3client.get_bucket_location(Bucket=bucket_name)['LocationConstraint']
url = "%s/%s" % (bucket_location, filename)
cid = att['content-id'].strip('<>')
data['media'].append({
'type': att['mail_content_type'],
'filename': att['filename'],
'url': url,
'cid': cid,
})
# if we only got html
if not 'body_plain' in data and 'body_html' in data:
data['body_plain'] = data['body_html'] # TODO: strip html
# if we only got plain text
if not 'body_html' in data and 'body_plain' in data:
data['body_html'] = data['body_plain']
# update src of embedded images
if 'body_html' in data:
for att in data['media']:
if att['cid']:
data['body_html'] = data['body_html'].replace('cid:{}'.format(att['cid']), att['url'])
issuer = Issuer.from_email(data['from_email'][0][1])
data['issuer_id'] = issuer.get_id() if isinstance(issuer, Issuer) else None
data['issuer_name'] = issuer.get_name() if isinstance(issuer, Issuer) else None
return cls(data)
def process_message(self, peer, mailfrom, rcpttos, data):
parsed = mailparser.parse_from_string(data)
sender = parsed.from_[0][0]
_from = parsed.from_[0][1]
_to = parsed.to[0][1]
print('New email to %s.' % _to)
_date = int(time.time())
body = str(base64.b64encode(parsed.body.encode()), 'utf-8')
params = (_date, sender, _from, _to, body)
c.execute('INSERT INTO mails VALUES (?, ?, ?, ?, ?)', params)
conn.commit()
def main():
args = get_args().parse_args()
if args.file:
if args.outlook:
parser = mailparser.parse_from_file_msg(args.file)
else:
parser = mailparser.parse_from_file(args.file)
elif args.string:
parser = mailparser.parse_from_string(args.string)
if args.json:
j = json.loads(parser.parsed_mail_json)
safe_print(json.dumps(j, ensure_ascii=False, indent=4))
if args.body:
# safe_print(parser.body)
safe_print(parser.body)
if args.headers:
safe_print(parser.headers)
if args.to:
safe_print(parser.to_)
if args.from_:
safe_print(parser.from_)
if args.subject:
safe_print(parser.subject)
if args.receiveds:
safe_print(parser.receiveds)
if args.defects:
for i in parser.defects_category:
safe_print(i)
if args.anomalies:
for i in parser.anomalies:
safe_print(i)
if args.senderip:
r = parser.get_server_ipaddress(args.senderip)
if r:
safe_print(r)
else:
safe_print("Not Found")
if args.attachments or args.attachments_hash:
print_attachments(parser.attachments_list, args.attachments_hash)
if args.mail_hash:
print_mail_fingerprints(parser.body.encode("utf-8"))
def read_emails(emails_dir):
emails = pd.DataFrame()
for filename in os.listdir(emails_dir):
f = open(os.path.join(emails_dir, filename),
"r",
encoding='ISO-8859-1')
raw_email = f.read()
mail = mailparser.parse_from_string(raw_email)
emails = emails.append({
'body': mail.body,
'headers': 'mail.headers'
},
ignore_index=True)
return emails
def get(self):
# production UNSEEN development ALL
result_emails = []
messages = self.client.search(['ALL'])
responses = self.client.fetch_email_messages(messages)
for message_id, data in responses.items():
mail = mailparser.parse_from_string(data.as_string())
path_list = self.save_attachments(mail.attachments)
result = {
'subject': mail.subject,
'message': mail.text_plain[-1],
'attachments': path_list,
'date': mail.date
}
def inbound_parse():
"""Process POST from Inbound Parse and print received data."""
parse = Parse(config, request)
print("Email!")
raw_email = parse.get_raw_email()
try:
email = \
{
"raw_email": raw_email,
"created_timestamp": datetime.datetime.now()
}
inserted_email = db_emails_collection.insert_one(email).inserted_id
print("Saved last email in database!", inserted_email)
except Exception as e:
print(e)
print("Could not save last email to database")
mail = mailparser.parse_from_string(raw_email)
print("Attachments", len(mail.attachments))
for attached_file in mail.attachments:
try:
raw_payload = attached_file["payload"]
if attached_file["content_transfer_encoding"] == "base64":
payload_bytes = base64.b64decode(raw_payload)
html_payload = payload_bytes.decode("utf-8")
else:
html_payload = raw_payload
highlights = parse_highlights(html_payload)
print(f"Received and parsed highlights for {highlights['title']}")
try:
db_highlights_collection.remove({
"title":
highlights["title"],
"authors":
highlights["authors"]
})
inserted_highlights = db_highlights_collection.insert_one(
highlights).inserted_id
print("Saved highlights to database", inserted_highlights)
except Exception as e:
print(e)
print("Could not save highlights to database")
SyncToNotion(highlights)
except Exception as e:
print(e)
print("Could not process attached file")
return "OK"
def deletet():
try:
args = request.args
mail_id = args['mail_id']
mail = imaplib.IMAP4_SSL("imap.gmail.com", 993)
mail.login(args['email'], args['password'])
mail.list()
mail.select('inbox')
# # type, data = mail.search(None, '(UNSEEN)')
type, data = mail.search(None, 'ALL')
mail_ids = data[0]
print('mail_ids', mail_ids)
id_list = mail_ids.split()
# first_email_id = int(id_list[0])
# latest_email_id = int(id_list[-1])
print("========++++++++++========== id_list ", id_list)
for num, i in enumerate(id_list):
print('iiiii========================', i, num)
typ, data = mail.fetch(i, '(RFC822)')
raw_email = data[0][1]
raw_email = str(raw_email, 'utf-8')
mail_data = mailparser.parse_from_string(raw_email)
data = {
'id': mail_data.message_id,
'subject': mail_data.subject,
'from': mail_data.from_,
'body': mail_data.body
}
print(data['id'].replace('+', ' '), mail_id)
# mail.store(i, '+X-GM-LABELS', '\\Trash')
if data['id'].replace('+', ' ') == mail_id:
print('Match', data['id'])
mail.store(i, '+X-GM-LABELS', '\\Trash')
mail.expunge()
mail.close()
mail.logout()
return jsonify({'success': 'true', 'message': 'Delete successfully'})
except Exception as e:
print(e)
return jsonify({
'success': 'false',
'message': 'some thing is wrong with login credentials'
})
def recv_mail_weibo(self, subject_pattern, from_email_pattern):
if not self.downloader:
slog.warning("downloader not login")
if not self.login():
return
self.downloader.select() # Select inbox or default namespace
(retcode, messages) = self.downloader.search(None, '(UNSEEN)')
if retcode != 'OK':
slog.warning("read mail from server failed")
return False
for num in messages[0].split():
slog.info('Processing: {0}'.format(num))
typ, data = self.downloader.fetch(num.decode('utf-8'), '(RFC822)')
email_message = email.message_from_string(
data[0][1].decode('utf-8'))
# mail to string
fp = StringIO()
g = generator.Generator(fp, mangle_from_=True, maxheaderlen=60)
g.flatten(email_message)
email_text = fp.getvalue()
# mail_string to json_string
pmail = mailparser.parse_from_string(email_text)
email_json = pmail.mail_json
# mail to json obj
email_data = json.loads(email_json)
subject = email_data.get('subject')
if subject.find(subject_pattern) == -1:
continue
from_email = email_data.get('from')[0] # list
if from_email_pattern not in from_email:
continue
# 标记已读
sr = self.downloader.store(num, '+FLAGS', '\Seen')
# 标记删除
#sr = downloader.store(num, '+FLAGS', '\\Deleted')
# find target email
body = email_data.get('body')
slog.info("read email: subject:{0} body size:{1}".format(
subject, len(body)))
vcode = body.split('\n')[0]
return vcode
return ''
def endpoint(event, context):
if 'ses' not in event['Records'][0]:
print(
'this was not an SES event. event["Records"][0]["ses"] not found')
return
ses_notification = event['Records'][0]['ses']
mail_message_id = ses_notification['mail']['messageId']
print(f"Message Id received: {mail_message_id}")
try:
data = s3.get_object(Bucket=SES_S3_BUCKET_NAME, Key=mail_message_id)
raw_email = data['Body'].read()
parsed_email = mailparser.parse_from_string(raw_email.decode('utf-8'))
process_incoming_mail(parsed_email)
except Exception as e:
print(e)
raise e
def check_if_recipient_is_vip(list_data):
raw_string = ''
for line in list_data:
if 'append "[Gmail]/Sent Mail"' not in line:
raw_string += line
mail = mailparser.parse_from_string(raw_string)
mail_to = mail.to[0][1]
mail_from = mail.from_[0][1]
mutation.mutate_and_send(mail)
if mail_to in vip_list:
return True, mail
else:
return False, mail
def trash():
try:
args = request.args
mail = imaplib.IMAP4_SSL("imap.gmail.com", 993)
mail.login(args['email'], args['password'])
mail.list()
# print(mail.list())
# mail.select('Travel')
# mail.select('INBOX')
mail.select('"[Gmail]/Trash"')
type, data = mail.search(None, 'ALL')
mail_ids = data[0]
# print('======>',mail_ids)
id_list = mail_ids.split()
first_email_id = int(id_list[0])
latest_email_id = int(id_list[-1])
print('======>', first_email_id, latest_email_id)
# for i in reversed(range(first_email_id, latest_email_id)):
email = []
# id_list = id_list.reverse()
for idx, i in reversed(list(enumerate(id_list))):
print('iiiii========================', i, idx)
typ, data = mail.fetch(i, '(RFC822)')
raw_email = data[0][1]
raw_email = str(raw_email, 'utf-8')
mail_data = mailparser.parse_from_string(raw_email)
data = {
'id': mail_data.message_id,
'subject': mail_data.subject,
'from': mail_data.from_,
'body': mail_data.body
}
email.insert(idx, data)
if idx == 20:
break
return jsonify(email)
except Exception as e:
return jsonify({
'success': 'false',
'message': 'some thing is wrong with login credentials'
})
def searchMailBySubject(self, **args):
"""This function will search for a particular mail as per the given sender and subject"""
try:
output = ""
attach_list = list()
mail_list = list()
FROM_EMAIL = args["username"]
FROM_PWD = args["password"]
subject = args["subject"]
SMTP_SERVER = "imap.gmail.com"
SMTP_PORT = 993
mail = imaplib.IMAP4_SSL(SMTP_SERVER)
try:
mail.login(FROM_EMAIL, FROM_PWD)
except:
return ["Authentication failed, contact admin", []]
mail.select('inbox')
type, data = mail.search(
None, '(SUBJECT "{subject}")'.format(subject=subject))
# search and return uids instead
mail_count = len(
data[0].split()) # data[0] is a space separate string
if (mail_count == 0): # if there are no mails found, i==0
return ["No mails!!", attach_list]
latest_email_uid = data[0].split()[
-1] # unique ids wrt label selected
result, email_data = mail.fetch(latest_email_uid, '(RFC822)')
# fetch the email body (RFC822) for the given ID
raw_email = email_data[0][1]
# continue inside the same for loop as above
raw_email_string = raw_email.decode('utf-8')
email = mailparser.parse_from_string(raw_email_string)
attach = email.attachments
if (len(attach) > 0):
for i in range(len(attach)):
attach_list.extend(attach[i]['filename'])
output = "Email from " + email.from_[0][1] + " dated " + str(
email.date
) + " on the subject " + email.subject + " is " + self.remove_html_tags(
str(email.text_html))
return [output, attach_list]
mail.close()
mail.logout()
except:
return ["Some error occured, try again!", []]
def read_email_from_gmail():
try:
args = request.args
mail = imaplib.IMAP4_SSL("imap.gmail.com", 993)
mail.login(args['email'], args['password'])
mail.list()
mail.select('inbox')
# type, data = mail.search(None, '(UNSEEN)')
type, data = mail.search(None, 'ALL')
mail_ids = data[0]
id_list = mail_ids.split()
first_email_id = int(id_list[0])
latest_email_id = int(id_list[-1])
# print(id_list)
# for i in reversed(range(first_email_id, latest_email_id)):
email = []
for idx, i in enumerate(id_list):
# print('iiiii========================', i)
typ, data = mail.fetch(i, '(RFC822)')
raw_email = data[0][1]
raw_email = str(raw_email, 'utf-8')
mail_data = mailparser.parse_from_string(raw_email)
data = {
'id': mail_data.message_id,
'subject': mail_data.subject,
'from': mail_data.from_,
'body': mail_data.body
}
email.insert(idx, data)
if idx == 20:
break
return jsonify(email)
except Exception as e:
return jsonify({
'success': 'false',
'message': 'some thing is wrong with login credentials'
})
def get_emails(mail_path):
mbox = mailbox.mbox(mail_path)
parsed_emails = []
try:
mbox.lock()
except mailbox.ExternalClashError:
logging.error(
"Mailbox not consumed, it is being access by another program")
return parsed_emails, 0
keys = mbox.keys()
for key in keys:
email = mbox.pop(key)
parsed_emails.append(mailparser.parse_from_string(str(email)))
mbox.flush()
mbox.unlock()
mbox.close()
return parsed_emails, 1
async def handle_DATA(self, _, session, envelope):
print('Recieved message...')
# noinspection PyBroadException
try:
file_name = os.path.join('messages', str(uuid.uuid4().hex))
with open(file_name, 'w') as open_file:
content = envelope.original_content.decode('utf-8').replace(
"\r\r\n", "\r\n")
message = mailparser.parse_from_string(content)
json.dump(
{
'mail_from': envelope.mail_from,
'rcpt_tos': envelope.rcpt_tos,
'subject': message.subject,
'body': message.body,
'data': content,
'timestamp': datetime.utcnow().isoformat()
}, open_file)
return '250 OK'
except Exception:
return '500 Could not process your message'
def __init__(self, idd, text, label):
mail = mailparser.parse_from_string(text)
self.text = mail.body
self.num_attach = len(mail.attachments)
self.text_soup = BeautifulSoup(self.text, 'html.parser')
self.idd = idd
self.label = label
raw_text = self.text_soup.get_text()
self.sents = nltk.tokenize.sent_tokenize(raw_text, language='english')
self.num_word = len(raw_text)
# Preprocess text
trans = str.maketrans('', '', string.punctuation)
raw_text = raw_text.lower().translate(trans) # strip puncuation
self.tokens = nltk.tokenize.word_tokenize(raw_text, language='english')
title = mail.subject.lower().translate(trans)
self.title_tokens = nltk.tokenize.word_tokenize(title,
language='english')
self.avg_word_len = reduce(lambda x, y: x + len(y), self.tokens,
0) / (len(self.tokens) + 1)
self.tokens = [
w for w in self.tokens if not w in stopwords.words('english')
]
stemmer = PorterStemmer()
self.tokens = [stemmer.stem(w) for w in self.tokens] # remove stems
self.title_tokens = [
w for w in self.title_tokens if not w in stopwords.words('english')
]
self.title_tokens = [stemmer.stem(w)
for w in self.title_tokens] # remove stems
self.word_freq = Counter(self.tokens)
self.title_word_freq = Counter(self.title_tokens)
def return_emails_from_imap(email_account,
password,
email_folder,
search_term="ALL",
url='imap.gmail.com'):
M = imaplib.IMAP4_SSL(url)
try:
rv, data = M.login(email_account, password)
except imaplib.IMAP4.error:
print "Login Failed. Check Credentials and imap url."
return
rv, data = M.select(email_folder)
if rv != 'OK':
print "Email folder not found."
return
response = []
rv, data = M.search(None, search_term)
if rv != 'OK':
print "No unSeen Messages"
return
for num in data[0].split():
rv, data = M.fetch(num, '(RFC822)')
if rv != 'OK':
print "ERROR getting message", num
#return
msg = email.message_from_string(data[0][1])
parsed_msg = mailparser.parse_from_string(msg.as_string())
response.append(parsed_msg)
M.logout()
return response
def getEmails(self, query, fromDate):
cibusVoucherList = []
status, messages = self.mail.select("INBOX")
type, data = self.mail.search(None, query)
mail_ids = data[0]
id_list = mail_ids.split()
ids_len = len(id_list)
for i in range(ids_len):
email_id = id_list[i]
print("{} - {}/{}".format(email_id, i, ids_len))
try:
typ, data = self.mail.fetch(email_id, '(RFC822)')
raw_email = data[0][1]
raw_email_string = raw_email.decode('utf-8')
email_msg = mailparser.parse_from_string(raw_email_string)
email_date = email_msg.date.date()
if (email_date >= fromDate):
barname = re.findall(
'https?:\/\/(?:www\.)?mysodexo\.co\.il\/b\?([-a-zA-Z0-9()@:%_\+.~#?&=]*)',
email_msg.body)[0]
# Get voucher value
subject = email_msg.headers['Subject']
decoded_subject, charset = decode_header(subject)[0]
voucher_value = re.findall('[\s\S]*?([0-9]+) ',
decoded_subject)[0]
# Go to bar url and extract barcode
link = "https://www.mysodexo.co.il/b?" + barname
f = requests.get(link)
barcode = re.findall('alt="([0-9]+)"', f.text)[0]
# Build image url
imgurl = 'https://www.mysodexo.co.il/b/bar.ashx?' + barname
title = barcode + '(' + str(voucher_value) + ')'
cell = '<div style="text-align:center;flex:1;font-family:Arial;margin-top:2px;margin-bottom:2px;-webkit-transform: rotate(90deg);transform: rotate(90deg);"><img height=1300 width=6000 src="' + imgurl + '" style="padding-top:8px;padding-bottom:8px;display:block;image-rendering:pixelated;" />' + barcode + '(' + str(
voucher_value) + ')' + '</div>'
response = requests.get(imgurl).raw
png_format = "{}\{}.png".format(MAIN_OUTPUT_FOLDER,
barcode)
jpeg_format = "{}\{}.jpeg".format(MAIN_OUTPUT_FOLDER,
barcode)
(filename,
headers) = urllib.request.urlretrieve(imgurl, png_format)
img = Image.open(png_format).convert('RGB').resize(
(900, 450)).save(jpeg_format, "JPEG", optimize=True)
cibusVoucherList.append(
CibusVoucher(email_date, voucher_value, barcode,
jpeg_format))
print("Voucher for {}, value {} barcode {}".format(
email_date, voucher_value, barcode))
else:
break
except Exception as e:
print(e)
continue
return cibusVoucherList
def handle(self, *args, **options):
query = None
group = str(options.get('group'))
subject = settings.EMAILS['tag'] + ' [' + str.upper(group) + '] '
emails = ()
# get raw email message
message = email.message_from_string(options.get('message').read())
mail = mailparser.parse_from_string(options.get('message').read())
# get email parts from raw source
# body = message.get_body()
# attachments = message.iter_attchments()
# body = ''
# attachments = []
# if message.is_multipart():
# for part in message.walk():
# if part.get_content_maintype() == 'multipart':
# if part.get('Content-Disposition') is None:
# filename = part.get_filename()
# payload = part.get_payload(decode=True)
# attachments.append({'name':filename,'content':payload})
# else:
# body += part.get_payload()
# else:
# body = message.part.get_payload()
sender = str(message['from'])
dest = str(message['to'])
try:
message.replace_header('Reply-To', group+'@'+settings.EMAILS['domain'])
except KeyError:
message.add_header('Reply-To', group+'@'+settings.EMAILS['domain'])
subject += str(message['subject']).replace(subject,'')
message.replace_header('Subject', subject)
# self.stdout.write(self.style.NOTICE('''Groupmail from <'''+str(sender)+'''> to group: <'''+str(group)+'''>'''))
# get members based on requested "group"
query = None
if group == 'all':
query = Member.objects.filter(Q(status=Member.ACT) | Q(status=Member.HON) | Q(status=Member.WBE) | Q(status=Member.STB))
if group == 'members':
query = Member.objects.filter(Q(status=Member.ACT) | Q(status=Member.WBE))
if group == 'board':
query = Member.objects.filter(role__year=getSaison())
# send(forward) mail to people of selected group
server = smtplib.SMTP('localhost')
if query is not None:
for m in query:
message.replace_header("To", m.email)
server.sendmail(sender, m.email, message.as_string())
# notify_by_email(
# sender,
# m.email,
# subject,
# body,
# False,
# attachments,
# False
# )
# emails += (
# (
# subject,
# msg.as_string(),
# sender,
# [m.email,],
# ),
# )
# self.stdout.write(self.style.NOTICE('Prepared message for <'+str(m)+'>'))
# self.stdout.write(self.style.NOTICE('Sending message for <'+str(m)+'>'))
# send_mass_mail(emails)
server.quit()
