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.')})