def delete_draft(self, inbox_uid):
"""
Move the message from the "Drafts" folder and into the "Trash" folder.
Parameters
----------
inbox_uid : str
The public_id of the draft we want to delete on the remote,
which is its X-INBOX-ID header too.
Notes
-----
Need the public_id == inbox_uid since that is the only unique
identifier for the message that both we and the remote know.
"""
assert inbox_uid
criteria = ['DRAFT', 'NOT DELETED']
all_draft_uids = self.conn.search(criteria)
# It would be nice to just search by X-INBOX-ID header too, but some
# backends don't support that. So fetch the header for each draft and
# see if we can find one that matches.
# TODO(emfree): are there other ways we can narrow the result set a
# priori (by subject or date, etc.)
matching_draft_headers = self.conn.fetch(all_draft_uids,
['BODY.PEEK[HEADER]'])
for uid, response in matching_draft_headers.iteritems():
headers = response['BODY[HEADER]']
parser = HeaderParser()
x_inbox_id = parser.parsestr(headers).get('X-Inbox-Id')
if x_inbox_id == inbox_uid:
# TODO: do we need this part?
# Remove IMAP `Draft` label
self.conn.remove_flags([uid], ['\Draft'])
self.conn.delete_messages([uid])
self.conn.expunge()
# Delete from `Trash`
# Needed because otherwise deleting a draft that was sent
# results in it synced twice - once via the Trash folder and
# once via the Sent folder.
self.conn.select_folder(self.folder_names()['trash'])
all_trash_uids = self.conn.search()
all_trash_headers = self.conn.fetch(all_trash_uids,
['BODY.PEEK[HEADER]'])
for u, r in all_trash_headers.iteritems():
x_inbox_header = HeaderParser().parsestr(
r['BODY[HEADER]']).get('X-Inbox-Id')
if x_inbox_header == inbox_uid:
self.conn.delete_messages([u])
self.conn.expunge()
return
def gmail_for_techxpo_test_refresh():
global imap_server
global imap_nickname
global imap_username
global imap_pass
global mail
global unread_count_initial
unread_count_current = re.search("UNSEEN (\d+)",
mail.status("INBOX",
"(UNSEEN)")[1][0]).group(1)
if unread_count_current != unread_count_initial:
mail.select()
#finding total mail count where latest email = mail count
status, mail_count = mail.search(None, 'ALL')
mail_count = mail_count[0].split()
mail_count = int(mail_count[-1])
#getting data from latest email
email_data = mail.fetch(mail_count, '(BODY.PEEK[])')
header_data = email_data[1][0][1]
parser = HeaderParser()
email_info = parser.parsestr(header_data)
#email sender
email_from = email_info['From']
email_from = email_from.split("<")[0]
#email subject line
email_subject = email_info['Subject']
#print to prompt for debugging purposes
unread_count_initial = unread_count_current
return "New " + imap_nickname + " from " + email_from
return None
def sync_result(self, sync_result):
self.data = sync_result["Properties"]["Body"]["Data"]
print "MSG SYNC RESULT", sync_result["Properties"]["Body"]
if int(sync_result["Properties"]["Body"]["Type"]) == 4: # mime type
# process headers
hp = HeaderParser()
self.parsed_message = hp.parsestr(self.data, True)
def checkMailForNewCommands():
logger.info('checking gmail for commands...')
conn = imaplib.IMAP4_SSL(imap_server)
try:
(retcode, capabilities) = conn.login(USERNAME, PASSWORD)
except:
logger.error(sys.exc_info()[1])
sys.exit(1)
conn.select() # Select inbox or default namespace
(retcode, messages) = conn.uid('search', None, '(UNSEEN)')
if retcode == 'OK':
for uid in messages[0].split():
logger.info('Found an unread message with id: ' + uid)
data = conn.uid('fetch', uid, '(BODY[HEADER])')
header_data = data[1][0][1]
parser = HeaderParser()
msg = parser.parsestr(header_data)
subjectText = msg["Subject"].lower()
if not subjectText.startswith("[command]"):
continue
# if we've already processed this email, move on
if uid in completedCommands:
continue
commandString = subjectText.split("[command]")[1].strip()
completedCommands[uid] = commandString
markCommandMailAsRead(conn, uid)
sendCommand(commandString)
pickle.dump(completedCommands, open(storageFileName, "wb"))
conn.close()
def parse_docstring(docstring):
"""
Parse out the parts of a docstring. Return (title, body, metadata).
"""
if not docstring:
return '', '', {}
docstring = cleandoc(docstring)
parts = re.split(r'\n{2,}', docstring)
title = parts[0]
if len(parts) == 1:
body = ''
metadata = {}
else:
parser = HeaderParser()
try:
metadata = parser.parsestr(parts[-1])
except HeaderParseError:
metadata = {}
body = "\n\n".join(parts[1:])
else:
metadata = dict(metadata.items())
if metadata:
body = "\n\n".join(parts[1:-1])
else:
body = "\n\n".join(parts[1:])
return title, body, metadata
def each(self, target):
self.results = {}
header_raw = open(target, 'r').read()
header = HeaderParser()
parsed_headers = header.parsestr(header_raw)
# Get Useful Headers
self.results['From'] = decode_mime_words(parsed_headers['From'])
self.results['ReturnPath'] = decode_mime_words(
parsed_headers['Return-Path'])
self.results['ReplyTo'] = decode_mime_words(parsed_headers['Reply-To'])
self.results['To'] = decode_mime_words(parsed_headers['To'])
self.results['Subject'] = decode_mime_words(parsed_headers['Subject'])
self.results['Date'] = parsed_headers['Date']
self.results['Cc'] = decode_mime_words(parsed_headers['Cc'])
# Parse Received and Authentication Headers
self.results['Received'] = self.parse_received(
parsed_headers.get_all('Received'))
self.results['DKIM'] = self.parse_dkim(parsed_headers.items())
self.results['SPF'] = self.parse_spf(parsed_headers.items())
self.results['DMARC'] = self.parse_dmarc(parsed_headers.items())
self.results['headers'] = parsed_headers.items()
self.results['highlight'] = self.highlight
return True
def setup():
global TTS
global PARSER
global IMAP_SERVER
global MAIL_SERVERS
IMAP_SERVER = None
PARSER = HeaderParser()
TTS = pyttsx3.init()
TTS.say(' ')
TTS.runAndWait()
MAIL_SERVERS = {
'gmail.com': {
'Server': str(socket.gethostbyname('imap.gmail.com'))
},
'yahoo.com': {
'Server': str(socket.gethostbyname('imap.mail.yahoo.com'))
},
'aol.com': {
'Server': str(socket.gethostbyname('imap.aol.com'))
}
}
def get_addresses(maildir):
emails = {}
for root, _dirs, files in os.walk(maildir):
for fname in files:
fname = os.path.join(root, fname)
msg = HeaderParser().parse(open(fname))
froms = msg.get_all('from', [])
tos = msg.get_all('to', [])
ccs = msg.get_all('cc', [])
resent_tos = msg.get_all('resent-to', [])
resent_ccs = msg.get_all('resent-cc', [])
all_recipients = getaddresses(froms + tos + ccs + resent_tos +
resent_ccs)
for (title, addr) in all_recipients:
emails.setdefault(addr, set()).add(title)
for addr, titles in emails.iteritems():
clean = set()
for title in titles:
if title.startswith('=?'):
title = dheader(title)
title = title.strip("'\"<>").replace('\n', ' ')
if title and title != addr:
clean.add(title)
if clean:
for title in clean:
yield addr, title
else:
yield addr, ''
def parse_content(content):
parser = HeaderParser()
data = dict()
msg = parser.parsestr(content)
subject = msg.get_all('subject')
if subject:
data['Subject'] = subject
from_ = getaddresses(msg.get_all('from', []))
if len(from_) > 0:
data['From'] = from_
to_ = getaddresses(msg.get_all('to', []))
if len(to_) > 0:
data['To'] = to_
cc = getaddresses(msg.get_all('cc', []))
if len(cc) > 0:
data['Cc'] = cc
bcc = getaddresses(msg.get_all('bcc', []))
if len(bcc) > 0:
data['Bcc'] = bcc
sender_ip = msg.get_all('x-originating-ip') # For Microsoft Exchange
sender_ip_list = list()
if sender_ip:
for ips in sender_ip:
sender_ip_list.append(ips.strip('[]'))
if len(sender_ip_list) > 0:
data['Sender IP'] = sender_ip_list
return data
def get_senders(email_ids):
senders_list = [] #creates senders_list list
for e_id in email_ids[0].split(): #Loops IDs of a new emails created from email_ids = imap_server.search(None, '(UNSEEN)')
resp, data = imap_server.fetch(e_id, '(RFC822)') #FETCH command retrieves data associated with a message in the mailbox. The data items to be fetched can be either a single atom or a parenthesized list. Returned data are tuples of message part envelope and data.
perf = HeaderParser().parsestr(data[0][1]) #parsing the headers of message
senders_list.append(perf['From']) #Looks through the data parsed in "perf", extracts the "From" field
return senders_list
def load_files(file_names):
subjects = []
errors = []
empty = 0
parser = HeaderParser()
for file_name in file_names:
with open(file_name, 'r') as file:
try:
msg = parser.parse(file)
subject = msg['Subject'].replace(',',
'').replace('\n', '').replace(
'\t', '').strip()
if len(subject):
subjects.append(subject)
else:
empty += 1
except UnicodeDecodeError:
errors.append(file_name)
except:
errors.append(file_name)
print('file_names', len(file_names))
print('valid subjects', len(subjects))
print('errors', len(errors))
print('empty', empty)
print()
return subjects
def getLastMail(connection_object):
inbox = connection_object.select('Inbox')
raw_mail = connection_object.fetch(int(inbox[1][0]),'(BODY[last_mail])')
raw_last_mail = raw_mail[1][0][1]
parser_object = HeaderParser()
last_mail = parser_object.parsestr(raw_last_mail)
return last_mail
def main():
outdir = os.path.join(os.path.dirname('__file__'), 'build')
try:
shutil.rmtree(outdir)
except FileNotFoundError:
pass
os.mkdir(outdir)
filenames = []
names = {}
for filename in sorted(glob.glob("pep-*.rst")):
outbasename = os.path.basename(filename[:-4] + '.html')
filenames.append(outbasename)
outfilename = os.path.join(outdir, outbasename)
pepnum = get_pepnum(outfilename)
print(filename, '->', outfilename)
with open(filename) as inf, open(outfilename, 'w') as outf:
fix_rst_pep(inf, outf, filename, pepnum)
with open(filename) as inf:
parser = HeaderParser()
metadata = parser.parse(inf)
names[pepnum] = metadata['Title']
index_filename = os.path.join(outdir, 'index.html')
print(index_filename)
with open(index_filename, 'w') as f:
f.write('<html><head><title>Draft PEP index</title></head>')
f.write('<body><h1>Draft PEP index</h1><ul>')
for filename in filenames:
pepnum = get_pepnum(filename)
f.write('<li>{num}: <a href="{link}">{name}</a></li>'.format(
link=filename, num=pepnum, name=names[pepnum]))
f.write('</ul></body></html>')
def each(self, target):
self.results = {}
header_raw = open(target, "r").read()
header = HeaderParser()
parsed_headers = header.parsestr(header_raw)
# Get Useful Headers
self.results["From"] = decode_mime_words(parsed_headers["From"])
self.results["ReturnPath"] = decode_mime_words(
parsed_headers["Return-Path"])
self.results["ReplyTo"] = decode_mime_words(parsed_headers["Reply-To"])
self.results["To"] = decode_mime_words(parsed_headers["To"])
self.results["Subject"] = decode_mime_words(parsed_headers["Subject"])
self.results["Date"] = parsed_headers["Date"]
self.results["Cc"] = decode_mime_words(parsed_headers["Cc"])
# Parse Received and Authentication Headers
self.results["Received"] = self.parse_received(
parsed_headers.get_all("Received"))
self.results["DKIM"] = self.parse_dkim(list(parsed_headers.items()))
self.results["SPF"] = self.parse_spf(list(parsed_headers.items()))
self.results["DMARC"] = self.parse_dmarc(list(parsed_headers.items()))
self.results["headers"] = list(parsed_headers.items())
self.results["highlight"] = self.highlight
return True
def main():
mailparser = HeaderParser()
imap = imaplib.IMAP4_SSL(host=IMAP_HOST, port=993)
imap.login(IMAP_USER, IMAP_PASS)
# names = [folder_name.decode('utf-8').split(' "/" ')[1] for folder_name in imap.list()[1]]
for folder_name in INCLUDED_FOLDERS:
imap.select(folder_name)
tmp, messages = imap.search(None, 'ALL')
# tmp, messages = imap.search(None, '(FROM "*****@*****.**")')
for message_id in reversed(messages[0].split()):
tmp, data = imap.fetch(message_id, '(BODY.PEEK[HEADER])')
msg = mailparser.parsestr(str(data[0][1].decode('utf-8')))
email = get_email(msg['From'])
if email in EXCLUDE_EMAILS:
print(f'DELETED: {decode_word(msg["Subject"])}')
ret = imap.store(message_id, '+FLAGS', '\\Deleted')
if ret[0] != 'OK':
print(ret)
imap.close()
imap.logout()
def analyse(raw_headers):
"""
sample output:
{
'To': u'*****@*****.**',
'From': u'Dhruv <*****@*****.**>',
'Cc': u'Shivam <*****@*****.**>',
'Bcc': u'Abhishek <*****@*****.**>',
'total_delay': 2,
'trail': [
{
'from': '',
'protocol': 'HTTP',
'receivedBy': '10.31.102.130',
'timestamp': 1452574216,
'delay': 0
},
{
'from': '',
'protocol': 'SMTP',
'receivedBy': 'mail-vk0-x22b.google.com',
'timestamp': 1452574218,
'delay': 2
},
{
'from': 'mail-vk0-x22b.google.com',
'protocol': 'ESMTPS',
'receivedBy': 'mx.google.com',
'timestamp': 1452574218,
'delay': 0
},
{
'from': '',
'protocol': 'SMTP',
'receivedBy': '10.66.77.65',
'timestamp': 1452574218,
'delay': 0
}
]
}
"""
if raw_headers is None:
return None
raw_headers = raw_headers.strip()
parser = HeaderParser()
headers = parser.parsestr(raw_headers.encode('ascii', 'ignore'))
received_headers = headers.get_all('Received')
trail = generate_trail(received_headers)
analysis = {
'From': decode_and_convert_to_unicode(headers.get('From')),
'To': decode_and_convert_to_unicode(headers.get('To')),
'Cc': decode_and_convert_to_unicode(headers.get('Cc')),
'Bcc': decode_and_convert_to_unicode(headers.get('Bcc')),
'trail': trail,
'total_delay': sum([hop['delay'] for hop in trail]) if trail else 0
}
return analysis
def check_email_get_targets():
status, email_ids = imap_server.search(None, '(UNSEEN)')
if email_ids == ['']:
print('No Unread Emails')
targets_list = []
else:
for e_id in email_ids[0].split():
resp, data = imap_server.fetch(e_id, '(RFC822)')
perf = HeaderParser().parsestr(data[0][1])
print('Perf: ' , perf)
targets_list.append(perf['To'])
print('List of Targets: ', targets_list)
imap_server.close()
return targets_list
if __name__ == '__main__':
imap_server = imaplib.IMAP4_SSL("imap.gmail.com",993)
imap_server.login(USERNAME, PASSWORD)
imap_server.select('INBOX')
target_list = check_email_get_targets()
if target_list :
print("I got an email")
else:
print("I got no email")
def find_emails_by_subject(self, subject, limit=50):
"""
Searches for Email by Subject. Returns email's imap message IDs
as a list if matching subjects is found.
Args:
subject (str) - Subject to search for.
Kwargs:
limit (int) - Limit search to X number of matches, default 50
Returns:
list - List of Integers representing imap message UIDs.
"""
# Select inbox to fetch the latest mail on server.
self._mail.select("inbox")
matches = []
parser = HeaderParser()
matching_msg_nums = self.__search_email_by_subject(subject)
for msg_num in matching_msg_nums[-limit:]:
_, msg_data = self._mail.fetch(msg_num, '(RFC822)')
raw_msg = msg_data[0][1]
msg_headers = parser.parsestr(raw_msg, True)
if msg_headers['subject'] == subject:
uid = re.search("UID\\D*(\\d+)\\D*",
self._mail.fetch(msg_num,
'UID')[1][0]).group(1)
matches.append(uid)
return matches
def parseHeaders(self, entry):
if (not getattr(self, 'headerParser', False)):
self.headerParser = HeaderParser(
) #See http://docs.python.org/library/email.parser.html#parser-class-api
headers = self.headerParser.parsestr(entry)
return headers
def message_delete(subject_message=None):
try:
server = connect_for_delete(GMAIL_IMAP_SERVER, GMAIL_IMAP_PORT,
GMAIL_USER, GMAIL_APP_PASSWORD)
# get list of mailboxes
mailparser = HeaderParser()
list = server.list()
server.select(GMAIL_FOLDER_NAME)
typ, data = server.search(None, 'ALL')
uids = data[0].split()
for num in uids:
try:
resp, data_second = server.fetch(num, '(RFC822)')
data_decode = data_second[0][1].decode()
msg = mailparser.parsestr(data_decode)
print('\nMessage №', num.decode())
print('From:', msg['From'], '\nDate:', msg['Date'],
'\nSubject:', msg['Subject'])
if msg['Subject'] == subject_message:
server.store(num, '+FLAGS', '\\Deleted')
print('_________Deleted Message_________\n')
except Exception as exception:
print("Error: %s!" % exception)
print('Id:', num)
server.expunge()
server.close()
print()
except Exception as exception:
print("Error: %s!\n\n" % exception)
def handle(self, *args, **options):
if len(args) != 1:
print('error: Need a project.')
sys.exit(1)
try:
project = Project.objects.get(linkname=args[0])
except Project.DoesNotExist:
print("error: can't find project '%s'" % args[0])
sys.exit(1)
parser = HeaderParser()
query = Patch.objects.filter(project=project)
count = query.count()
for i, patch in enumerate(query.iterator()):
if (i % 10) == 0:
sys.stdout.write("%06d/%06d\r" % (i, count))
sys.stdout.flush()
headers = parser.parsestr(patch.headers)
new_project = find_project(headers)
if new_project == patch.project:
continue
patch.project = new_project
patch.save()
series = find_series_for_patch(patch)
if not series:
continue
series.project = new_project
series.save()
sys.stdout.write("%06d/%06d\r" % (count, count))
sys.stdout.write('\ndone\n')
def haalHeader():
# Maak de verbinding met de mail server
mailserver = imaplib.IMAP4_SSL(HOSTNAME)
mailserver.login(USERNAME, PASSWORD)
mailserver.select(MAILBOX, readonly=True)
# Haal alle emails op die nog niet gelezen zijn
typ, data = mailserver.search(None, 'UNSEEN')
# Check of de verbinding is gelukt
if typ == "OK":
aantal_mails = len(data[0].split())
if aantal_mails == 0:
veranderLicht(aantal_mails)
for num in data[0].split():
mail = mailserver.fetch(num, '(BODY[HEADER])')
parser = HeaderParser()
msg = parser.parsestr(mail[1][0][1].decode("utf-8"))
# Roep csvCheck aan met de afzender en datum/tijd
csvCheck(msg["From"], msg["Date"], aantal_mails)
else:
print("Er is iets fout gegaan met het ophalen van de emails: " + typ)
# Sluit de mail verbinding
mailserver.close()
mailserver.logout()
return
def get(self, request, pk, *args, **kwargs):
try:
mdn = models.MDN.objects.get(message_id=pk)
if request.GET['action'] == 'downl':
response = HttpResponse(content_type='multipart/report')
disposition_type = 'attachment'
response[
'Content-Disposition'] = disposition_type + '; filename=' + pk + '.mdn'
response.write(as2utils.readdata(mdn.file))
return response
elif request.GET['action'] == 'this':
file_obj = dict()
file_obj['name'] = pk + '.mdn'
file_obj['id'] = pk
file_obj['content'] = as2utils.readdata(mdn.file,
charset='utf-8',
errors='ignore')
file_obj['direction'] = mdn.get_status_display()
file_obj['type'] = 'AS2 MDN'
file_obj['headers'] = dict(HeaderParser().parsestr(
mdn.headers or '').items())
return render(request, self.template_name,
{'file_obj': file_obj})
except Exception:
return render(request, self.template_name,
{'error_content': _(u'No such file.')})
def parse_email_header(header):
"""
Parses email headers and returns it as ordered list.
:param header: headers
:type header: str
:return: parsed headers
:rtype: tuple
"""
headers_order = {
'date': 1,
'from': 2,
'to': 3,
'subject': 4,
'return-path': 5,
'delivered-to': 6,
'in-reply-to': 7,
'message-id': 8,
'mime-version': 9,
'received': 10,
'x-mailer': 11
}
try:
parser = HeaderParser()
header = header.encode('utf-8')
parsed_headers = parser.parsestr(header)
if parsed_headers:
return True, [{
'key': header[0],
'value': header[1],
'order': headers_order.get(header[0].lower()) or 100
} for header in parsed_headers.items()]
else:
return False, {}
except (HeaderParseError, Exception):
return False, {}
def send(self, args):
"""Send an AMI request "action" given a dict of header values
Keyword Arguments:
args A dictionary of headers and values
Returns:
An email.message.Message which we could wrap with our own AMIMessage
class if we were feeling industrious. You can get
access the headers via:
ami = SyncAMI()
res = ami.send({'action': 'ping'})
res.items() => [("header", "value"), ...]
res.get("header") => "value"
res.get_all("header") => ["value", ...]
"""
headers = {}
params = "?" + urlencode(args)
if self.cookie is not None:
headers['Cookie'] = self.cookie
self.con.request("GET", self.path + params, headers=headers)
res = self.con.getresponse()
if res.status != 200:
raise InvalidAMIResponse(res)
self.cookie = res.getheader('set-cookie', None)
data = StringIO(res.read().decode('utf-8', 'ignore'))
res = HeaderParser().parse(data)
data.close()
return res
def setUpTestData(cls):
# Every test needs a client.
cls.client = Client()
cls.header_parser = HeaderParser()
# Load the client and server certificates
cls.server_key = models.PrivateCertificate.objects.create(
certificate=os.path.join(TEST_DIR, 'as2server.pem'),
certificate_passphrase='password')
cls.si_public_key = models.PublicCertificate.objects.create(
certificate=os.path.join(TEST_DIR, 'si_public_key.crt'),
ca_cert=os.path.join(TEST_DIR, 'si_public_key.ca'),
verify_cert=False)
# Setup the server organization and partner
cls.organization = models.Organization.objects.create(
name='Server Organization',
as2_name='as2server',
encryption_key=cls.server_key,
signature_key=cls.server_key)
cls.partner = models.Partner.objects.create(
name='Sterling B2B Integrator',
as2_name='SIAS2PRD',
target_url='http://localhost:8080/pyas2/as2receive',
compress=False,
mdn=False,
signature_key=cls.si_public_key,
encryption_key=cls.si_public_key)
# Initialise the payload i.e. the file to be transmitted
cls.payload = models.Payload.objects.create(
name='testmessage.edi',
file=os.path.join(TEST_DIR, 'testmessage.edi'),
content_type='application/edi-consent')
def check_mail():
global l_s
a,b=l_s.select('INBOX')
dataa=[]
try:
typ, dataa = l_s.uid('search','(SUBJECT "'+sub+'")','UNSEEN')
except Exception as s:
print s
data=dataa[0].split(' ')
if data != [''] and len(data)>0:
for x in range(0,len(data)):
typ,mail= l_s.uid('fetch', data[x], '(RFC822)')
parser = HeaderParser()
h = parser.parsestr(mail[0][1])
r_string=mail[0][1].decode('utf-8')
e_msg=email.message_from_string(r_string)
for part in e_msg.walk():
if part.get_content_type()=='text/plain':
body=part.get_payload(decode=True)
body=body.split('--')[0].replace('\r','').replace(' ','').replace('\t','')
print "Message: ",body
for scm in body.lower().replace('\r','').split('\n'):
dev,mode,val=wwe(scm.replace(' ','').replace('\t',''))
if str(val)=='0' or str(val)=='1':
dev_rply(h['Subject'],h['Message-ID'],h['From'],str(dev),str(val))
sleep(0.5)
def fetch(self):
mail = imaplib.IMAP4_SSL(self._smtp_server)
log.debug("Email smtp: {}".format(self._smtp_server))
log.debug("Email from: {}".format(self._from_email))
mail.login(self._from_email, self._from_pwd)
mail.select('inbox')
type, data = mail.search(None, 'ALL')
mail_ids = data[0]
id_list = mail_ids.split()
for email_id in id_list:
email_subject = None
sender = None
data = mail.fetch(str(int(email_id)), '(BODY[HEADER])')
header_data = data[1][0][1].decode()
parser = HeaderParser()
msg = parser.parsestr(header_data)
email_subject = msg['Subject'].strip()
sender = msg['From'].strip()
if self._sender_is_nok(sender):
log.warning("Non OK sender: {}".format(sender))
elif self._subject_is_cancel(email_subject):
log.info("Got Cancel")
self._delete(mail, id_list)
return
elif self._subject_is_time(email_subject):
self._create_will_leave_at(email_subject)
self._delete(mail, id_list)
return
self._delete(mail, id_list)
def get_subjects(email_ids):
subjects_list = []
for e_id in email_ids[0].split():
resp, data = imap_server.fetch(e_id, '(RFC822)')
perf = HeaderParser().parsestr(data[0][1])
subjects_list.append(perf['Subject'])
return subjects_list
def get(self, request, pk, *args, **kwargs):
try:
message = models.Message.objects.get(message_id=pk)
payload = message.payload
if request.GET['action'] == 'downl':
response = HttpResponse(content_type=payload.content_type)
dispositiontype = 'attachment'
response['Content-Disposition'] = dispositiontype + '; filename=' + payload.name
response.write(as2utils.readdata(payload.file))
return response
elif request.GET['action'] == 'this':
file_obj = dict()
file_obj['name'] = payload.name
file_obj['id'] = pk
file_obj['content'] = as2utils.readdata(payload.file,charset='utf-8',errors='ignore')
if payload.content_type == 'application/EDI-X12':
file_obj['content'] = viewlib.indent_x12(file_obj['content'])
elif payload.content_type == 'application/EDIFACT':
file_obj['content'] = viewlib.indent_edifact(file_obj['content'])
elif payload.content_type == 'application/XML':
file_obj['content'] = viewlib.indent_xml(file_obj['content'])
file_obj['direction'] = message.get_direction_display()
file_obj['type'] = 'AS2 MESSAGE'
file_obj['headers'] = dict(HeaderParser().parsestr(message.headers or '').items())
return render(request,self.template_name,{'file_obj': file_obj})
except Exception,e:
return render(request,self.template_name,{'error_content': _(u'No such file.')})
