def post(request): """ Add in a post """ log("Processing email message") mailobj = mail.InboundEmailMessage(request.raw_post_data) to = mailobj.to if to in settings.ALLOWED_RECEIVING_ADDRESSES: key = settings.ARECIBO_PUBLIC_ACCOUNT_NUMBER else: key = to.split("-", 1)[1].split("@")[0] if key != settings.ARECIBO_PUBLIC_ACCOUNT_NUMBER: log("To address (%s, to %s) does not match account number (%s)" % (key, to, settings.ARECIBO_PUBLIC_ACCOUNT_NUMBER)) return for content_type, body in mailobj.bodies("text/plain"): if mailobj.subject.find(" Broken ") > -1: log("Trying to parse body using 404 parser") result = parse_404(body, mailobj.subject) else: log("Trying to parse body using 500 parser") result = parse_500(body, mailobj.subject) err = Error() result["account"] = key populate(err, result) return render_plain("message parsed")
def post(self, reply_to_id): incoming_mail = mail.InboundEmailMessage(self.request.body) model = email_models.FeedbackEmailReplyToIdModel.get_by_reply_to_id( reply_to_id) if model is None: raise self.PageNotFoundException user_id = model.user_id exploration_id = model.exploration_id thread_id = model.thread_id # Get text message from email. msg = list( incoming_mail.bodies(content_type='text/plain'))[0][1].decode() # Add new feedback message to thread. feedback_services.create_message(exploration_id, thread_id, user_id, None, None, msg, received_via_email=True) self.render_json({})
def post(self, *args, **kwargs): msg = mail.InboundEmailMessage(self.request.body) logging.info('Mail from: {}'.format(msg.sender)) logging.info('Subject: {}'.format(msg.subject)) for content_type, body in msg.bodies(): logging.info(content_type) logging.info(body.decode())
def post(self): message = mail.InboundEmailMessage(self.request.body) ## Get the traderID from the post based on the email address and "forward" the email this_post = Post.query( Post.contact == message.to).order(-Post.engage).get() email_to = this_post.traderID if mail.is_email_valid(email_to): email_messages = message.bodies('text/plain') email = get_email_text("Post Reply") for content_type, msg in email_messages: full_message = mail.EmailMessage( sender="%s <%s@%s>" % (bitsettings.site_name, bitsettings.email_local, bitsettings.email_suffix), subject="%s %s - %s" % (bitsettings.email_subject, this_post.title, str(this_post.price)), to="%s <%s>" % (email_to.split('@')[0], email_to), reply_to=message.sender, body=email.find('header').text + "\n\n" + str(message.subject).upper() + "\n" + msg.decode() + "\n\n" + email.find('footer').text, ) full_message.send()
def setUp(self): super(FacebookEmailTest, self).setUp() self.fea = FacebookEmailAccount( id='212038', email_user='******', domain_urls=['http://foo.com/'], domains=['foo.com'], ) self.fea.put() self.handler = EmailHandler() self.handler.request = webapp2.Request.blank( '/_ah/mail/[email protected]') self.handler.response = self.response headers = Message() headers['Message-ID'] = 'SMTP-123-xyz' self.mail = mail.InboundEmailMessage( sender='*****@*****.**', to='*****@*****.**', subject='Ryan Barrett commented on your post.', body='plain text is useless', html=COMMENT_EMAIL_USERNAME, mime_message=headers, ) gr_facebook.now_fn = lambda: datetime(1999, 1, 1)
def post(self, reply_to_id): incoming_mail = mail.InboundEmailMessage(self.request.body) if feconf.ENABLE_GENERALIZED_FEEDBACK_THREADS: model = (email_models.GeneralFeedbackEmailReplyToIdModel. get_by_reply_to_id(reply_to_id)) else: model = email_models.FeedbackEmailReplyToIdModel.get_by_reply_to_id( reply_to_id) if model is None: raise self.PageNotFoundException user_id = model.user_id thread_id = model.thread_id # Get text message from email. msg = list( incoming_mail.bodies(content_type='text/plain'))[0][1].decode() # Add new feedback message to thread. feedback_services.create_message(thread_id, user_id, None, None, msg, received_via_email=True) self.render_json({})
def post(self, **kwargs): """Transforms body to email request. :param kwargs: Keyword arguments from the matched URL rule. """ return self.receive(mail.InboundEmailMessage(self.request.data), **kwargs)
def emailToCard(request): if request.POST: message = mail.InboundEmailMessage(request.raw_post_data) logging.info("Email To Card from " + message.sender) (front, back, settings, fields) = parseEmail(message) if settings != None: createCardFromEmail(front, back, settings, fields) return HttpResponse('ok')
def update(self, to): message = mail.InboundEmailMessage(self.request.body) # Ensure that the message always has a subject if not hasattr(message, "subject"): message.subject = "<no subject>" # We want the plaintext version of the body (not the HTML formatted one) (_, encoded_body), = list(message.bodies("text/plain")) # Split the body into lines and keep all the lines until we see the first # "quoted" line (starting with >). lines = [] for line in encoded_body.decode().split("\n"): if line.startswith(">"): break # Strip trailing whitespace and add to the list of lines. lines.append(line.rstrip()) # Get rid of any trailing whitespace from the chunk of text. lines = "\n".join(lines).strip().split("\n") # If the last line contains noreply@dailymeeting, it's VERY likely a # 'reply', so remove it. if "*****@*****.**" in lines[-1]: lines = lines[:-2] # Put the lines back together to form the final body. body = "\n".join(lines).strip() # Log that the e-mail happened. The record will also exist in the mailbox # for [email protected]. template = (u"Received inbound e-mail message:\n" u"From: {message.sender}\n" u"To: {message.to}\n" u"Subject: {message.subject}\n" u"Body:\n" u"=== Original ===\n" u"{original_body}\n" u"=== End Original ===\n" u"=== Trimmed ===\n" u"{body}\n" u"=== End Trimmed ===") logging.info(template.format(message=message, body=body, original_body=encoded_body.decode())) if not body: logging.info("Body was empty, skipping note.") return email = message.sender if '<' in email and email.endswith('>'): email = email[:-1].split('<', 2)[1]
def __init__(self, body): # make email obj from body message = mail.InboundEmailMessage(body) # list of emails: ['*****@*****.**', ...] self.to = [a[1] for a in getaddresses([message.to])] self.cc = [a[1] for a in getaddresses([getattr(message, 'cc', '')])] self.recipient = None # check hook recipient in message.to list first for addr in self.to: if (addr.split('@')[1] == 'emailhooks.xyz'): self.recipient = addr.split('@')[0] break # if not in message.to, parse hook recipient from forwarding # details following the patterns: # "for <_____ @emailhooks.xyz>" or "for _____ @emailhooks.xyz" if (self.recipient is None): match = re.search('for <?(\S+)@emailhooks\.xyz', body, re.IGNORECASE) self.recipient = match.group(1).lower() if match else None self.sender = parseaddr(message.sender)[1] self.subject = getattr(message, 'subject', '') self.date = message.date self.html_body = '' for _, body in message.bodies('text/html'): self.html_body = body.decode() self.plain_body = '' for _, plain in message.bodies('text/plain'): self.plain_body = plain.decode() # Attachments are a list of tuples: (filename, EncodedPayload) # EncodedPayloads are likely to be base64 # # EncodedPayload: # https://cloud.google.com/appengine/docs/python/refdocs/google.appengine.api.mail#google.appengine.api.mail.EncodedPayload # self.attachments = [] for attachment in getattr(message, 'attachments', []): encoding = attachment[1].encoding payload = attachment[1].payload if (not encoding or encoding.lower() != 'base64'): payload = attachment[1].decode().encode('base64') self.attachments.append({ 'filename': attachment[0], 'payload': payload })
def _assertGoogleDocIdExtraction(self, filename, expected_google_doc_ids): email_raw = None f = open("test_emails/%s" % filename, "r") with f: email_raw = f.read() inbound_msg = google_mail_api.InboundEmailMessage(email_raw) google_doc_ids = (mail.NewProjectsMailHandler. google_doc_ids_from_message(inbound_msg)) self.assertEquals(sorted(expected_google_doc_ids), sorted(google_doc_ids))
def email_to_feed(email): logger.info('Email: %s', email) account, _ = email.split('@', 1) logger.info('Account: %s', account) unique_key, feed_type, version = account.split('_') feed_type, version = map(int, (feed_type, version)) logger.info('unique_key: %s feed_type:%s version:%s', unique_key, feed_type, version) feed = FEED_TYPE_TO_CLASS[feed_type].for_email(unique_key) logger.info('Found feed: %s', feed) mail_message = mail.InboundEmailMessage(request.stream.read()) entry = yield feed.create_entry_from_mail(mail_message) yield publish_entry(entry, feed) raise ndb.Return(jsonify(status='ok'))
def post(self): message = mail.InboundEmailMessage(self.request.body) sender = message.sender url = message.subject try: result = urllib2.urlopen(url) page = result.read() out_message = mail.EmailMessage( sender=FROM, subject='RE: {}'.format(message.subject)) out_message.to = message.sender out_message.body = page out_message.html = page out_message.send() except urllib2.URLError, e: logging.exception(e)
def post(self, name): """Transforms body to email request.""" try: name = urllib.unquote(name).split('@')[0] except: pass # get the feed object feed = MailFeed.query(MailFeed.name == name).get() if feed is not None: self.receive(mail.InboundEmailMessage(self.request.body), feed) else: # 404 ? pass
def post(request): """ Add in a post """ log("Processing email message") mailobj = mail.InboundEmailMessage(request.raw_post_data) found = False for content_type, body in mailobj.bodies("text/plain"): found = parse(content_type, body) for content_type, body in mailobj.bodies("text/html"): found = parse(content_type, body) if not found: log("No contents found in the message.") return render_plain("message parsed")
def post(self): logging.info("Request headers:\n%s" % "\n".join("- %s: %s" % h for h in self.request.headers.iteritems())) body = self.request.body msg = mail.InboundEmailMessage(body) logging.debug("Received %.1fkB from '%s'" % (len(body) / 1024., msg.sender)) if msg.attachments: def attachment_info((filename, payload)): return "- '%s' (%.1fkB; %s)" \ % (filename, len(payload.decode()) / 1024., mail._GetMimeType(filename)) logging.debug("%d attachments:\n%s" % (len(msg.attachments), "\n".join( map(attachment_info, msg.attachments)))) ts = datetime.utcfromtimestamp( email.utils.mktime_tz(email.utils.parsedate_tz(msg.date))) to = sorted({s.strip() for s in msg.to.split(",")}) ent = Inmail( mail_timestamp=ts, sender=msg.sender, recipients=to, # the subject field is undefined if no subject subject=getattr(msg, 'subject', None), body=body) try: ent.put() except RequestTooLargeError: logging.exception("Failed to store Inmail") mail.send_mail( sender="info@%s.appspotmail.com" % get_application_id(), to=msg.sender, subject="Auto-reply: Too large email", body="Hello dear %s,\n\n" "An email you sent couldn't be received properly due to " "its excessive size (%.1fMB). Please retry with reduced " "attachments.\n\n" "Original email recipients: %s\n" "Subject: %s" % (msg.sender, len(body) / 1024.**2, msg.to, getattr(msg, 'subject', "(empty)"))) else: logging.info("Stored email to %r" % ent.key)
def post(self): from email import header, utils message = mail.InboundEmailMessage(self.request.body) texts = message.bodies('text/plain') for text in texts: txtmsg = "" txtmsg = text[1].decode() url = txtmsg.encode('utf8') bm = Bookmarks() def txn(): bm.original = url bm.title = header.decode_header(message.subject)[0][0] bm.comment = 'Sent via email' bm.user = users.User(utils.parseaddr(message.sender)[1]) bm.put() ndb.transaction(txn) deferred.defer(main_parser, bm.key, _queue="parser")
def from_upload(cls, reader): """ create from blobstore.BlobReader """ message = mail.InboundEmailMessage(reader.read()) item = cls() try: item.field_from = message.sender item.field_to = message.to item.field_subj = message.subject item.field_text = "".join([body.decode() for _ct, body in message.bodies('text/plain')]) item.field_html = "".join([body.decode() for _ct, body in message.bodies('text/html')]) except AttributeError: raise item.put() return item
def post(self): inbound_message = mail.InboundEmailMessage(self.request.body) logging.info("Email request! Sent from %s with message subject %s" % (inbound_message.sender, inbound_message.subject)) body = inbound_message.subject logging.debug("email body arguments %s" % body) ## magic ## response = api_bridge.getarrivals(body, 10) # to make it a little easier to read, add newlines before each route report line response = response.replace('Route', '\nRoute') # send back the reply with the results header = "Thanks for your request! Here are your results...\n\n" footer = "\n\nThank you for using SMSMyBus!\nhttp://www.smsmybus.com" # setup the response email message = mail.EmailMessage() message.sender = config.EMAIL_SENDER_ADDRESS message.bcc = config.EMAIL_BCC_ADDRESS message.to = inbound_message.sender message.subject = 'Your Metro schedule estimates for stop %s' % getStopID( body) message.body = header + response + footer logging.debug('sending results to %s' % message.to) message.send() # create an event to log the event task = Task(url='/loggingtask', params={ 'phone': inbound_message.sender, 'inboundBody': body, 'sid': 'email', 'outboundBody': response, }) task.add('eventlogger') self.response.set_status(200) return
def post(self, reply_to_id): incoming_mail = mail.InboundEmailMessage(self.request.body) feedback_thread_reply_info = ( email_services.get_feedback_thread_reply_info_by_reply_to_id( reply_to_id)) if feedback_thread_reply_info is None: raise self.PageNotFoundException user_id = feedback_thread_reply_info.user_id thread_id = feedback_thread_reply_info.thread_id # Get text message from email. msg = list( incoming_mail.bodies(content_type='text/plain'))[0][1].decode() # Add new feedback message to thread. feedback_services.create_message( thread_id, user_id, None, None, msg, received_via_email=True) self.render_json({})
def receive(self, mail_message): logging.info("Email from "+ mail_message.sender) messageRecieved = mail.InboundEmailMessage(self.request.body); if(messageRecieved.to.lower() == "*****@*****.**"): sources = auth.lookupEmail(messageRecieved.sender); senderName = messageRecieved.sender; if(sources.count() != 0): source = sources[0]; senderName = source.firstName + " " + source.lastName html = "" for htmlpart in messageRecieved.bodies(content_type='text/html'): html = html + htmlpart[1].decode() attachments = None if(hasattr(messageRecieved, "attachments")): attachments = messageRecieved.attachments mailToUserGroup("public",senderName,"Message from " + senderName + ": " + messageRecieved.subject,messageRecieved.body, html, attachments)
def __init__(self, post_vars): """Constructs a new BounceNotification from an HTTP request. Properties: original: a dict describing the message that caused the bounce. notification: a dict describing the bounce itself. original_raw_message: the raw message that caused the bounce. The 'original' and 'notification' dicts contain the following keys: to, from, subject, text Args: post_vars: a dict-like object containing bounce information. This is typically the self.request.POST variable of a RequestHandler object. The following keys are expected in the dict: original-from original-to original-subject original-text notification-from notification-to notification-subject notification-text raw-message Raises: InvalidBounceNotification if any of the expected fields are missing. """ try: self.__original = {} self.__notification = {} for field in ['to', 'from', 'subject', 'text']: self.__original[field] = post_vars['original-' + field] self.__notification[field] = post_vars['notification-' + field] self.__original_raw_message = mail.InboundEmailMessage( post_vars['raw-message']) except KeyError, e: raise InvalidBounceNotificationError(e[0])
def __init__(self, post_vars): """Constructs a new BounceNotification from an HTTP request. Properties: original: a dict describing the message that caused the bounce. notification: a dict describing the bounce itself. original_raw_message: the raw message that caused the bounce. The 'original' and 'notification' dicts contain the following keys: to, cc, bcc, from, subject, text Args: post_vars: a dict-like object containing bounce information. This is typically the self.request.POST variable of a RequestHandler object. The following keys are handled in the dict: original-from original-to original-cc original-bcc original-subject original-text notification-from notification-to notification-cc notification-bcc notification-subject notification-text raw-message """ self.__original = {} self.__notification = {} for field in ['to', 'cc', 'bcc', 'from', 'subject', 'text']: self.__original[field] = post_vars.get('original-' + field, '') self.__notification[field] = post_vars.get('notification-' + field, '') self.__original_raw_message = mail.InboundEmailMessage( post_vars.get('raw-message', ''))
def post(self): message = mail.InboundEmailMessage( self.request.body) #Accept in bound mails new_email = model.EmailArchive() #Set a new EmailArchieve entity new_email.from_ = message.sender new_email.subject = message.subject email_body = list(message.bodies(content_type='text'))[0] new_email.content = str( email_body[1]) #convert the message into readable string startIndex = 1 + new_email.from_.index('<') endIndex = new_email.from_.index('@') newString = new_email.from_[startIndex:endIndex] query = model.PlayerTag.query() for item in query: if (item.confirm == False and str(item.google_id) == newString and new_email.subject.__contains__(item.activationToken)): item.confirm = True item.put() new_email.put()
def post(self): """Transforms body to email request.""" self.receive(mail.InboundEmailMessage(self.request.body))
def post(self): # create email message and parse out fields message = mail.InboundEmailMessage(self.request.body) # list of emails: ['*****@*****.**', ...] to = [addr[1] for addr in getaddresses([message.to])] cc = [addr[1] for addr in getaddresses([getattr(message, 'cc', '')])] sender = parseaddr(message.sender)[1] subject = getattr(message, 'subject', '') date = message.date html_body = '' for _, body in message.bodies('text/html'): html_body = body.decode() plain_body = '' for _, plain in message.bodies('text/plain'): plain_body = plain.decode() # Attachements are a list of tuples: (filename, EncodedPayload) # EncodedPayloads are likely to be base64 # # EncodedPayload: # https://cloud.google.com/appengine/docs/python/refdocs/google.appengine.api.mail#google.appengine.api.mail.EncodedPayload # attachments = [] for attachment in getattr(message, 'attachments', []): encoding = attachment[1].encoding payload = attachment[1].payload if (not encoding or encoding.lower() != 'base64'): payload = attachment[1].decode().encode('base64') attachments.append({'filename': attachment[0], 'payload': payload}) # logging, remove what you find to be excessive logging.info('From <%s> to [<%s>]', sender, '>, <'.join(to)) logging.info('Subject: %s', subject) logging.info('Body: %s', plain_body) logging.info('Attachments: %s', [a['filename'] for a in attachments]) # change to your endpoint (httpbin is cool for testing though) url = 'http://httpbin.org/post' payload = json.dumps({ 'sender': sender, 'to': to, 'cc': cc, 'date': date, 'subject': subject, 'html_body': html_body, 'plain_body': plain_body, 'attachments': attachments }) # add a key if you want to sign each request, or remove these lines key = 'XXXXXXXXXXXXXXXXXXXX' # hmac needs bytes (str() == bytes() in python 2.7) signature = hmac.new(bytes(key), bytes(payload), hashlib.sha1).hexdigest() headers = { 'Content-Type': 'application/json', 'X-Email-Signature': signature, } # try to post to destination try: result = urlfetch.fetch(url=url, headers=headers, payload=payload, method=urlfetch.POST) logging.info('POST to %s returned: %s', url, result.status_code) logging.info('Response body: %s', result.content) except urlfetch.Error as err: logging.exception('urlfetch error posting to %s: %s', url, err)
def post(self, project_addr=None): logging.info('\n\n\nPOST for InboundEmail and project_addr is %r', project_addr) self.Handler(mail.InboundEmailMessage(self.request.body), urllib.unquote(project_addr))
def post(self, address): """Transforms body to email request.""" self.receive(mail.InboundEmailMessage(self.request.data), address) return Response("OK")
def post(self): message = mail.InboundEmailMessage(self.request.body) logging.info('Got e-mail: %s', message)
def _process_incoming_mail(raw_message, recipients, mailing_list): """Process an incoming email message.""" recipients = [x[1] for x in email.utils.getaddresses([recipients])] incoming_msg = mail.InboundEmailMessage(raw_message) mailing_list_acronym = mailing_list.split('/')[3].split('@')[0] query = models.MailingList.all().filter('acronym =', mailing_list_acronym.lower()) mailing_list = query.get() if mailing_list is None: # Create a new mailing-list newml = models.MailingList(name=mailing_list_acronym, acronym=mailing_list_acronym.lower()) newml.put() mailing_list = newml logging.info("Received a message from: " + incoming_msg.sender + " TO: " + str(recipients) + " for ML " + mailing_list_acronym) if 'X-Google-Appengine-App-Id' in incoming_msg.original: raise InvalidIncomingEmailError('Mail sent by App Engine') subject = incoming_msg.subject or '' sender = email.utils.parseaddr(incoming_msg.sender)[1] original = str(incoming_msg.original) body = None for content_type, payload in incoming_msg.bodies('text/plain'): body = payload.decode() break if body is None or not body.strip(): raise InvalidIncomingEmailError('Ignoring empty message.') # We need to check if the header is internationalized try: decoded_subject = email.header.decode_header(subject) if decoded_subject[0][1]: subject = decoded_subject[0][0].decode(decoded_subject[0][1]) except: logging.error('Unable to decode subject: %r', subject) # If the subject is long, this might come wrapped into more than one line. subject = ' '.join([x.strip() for x in subject.splitlines()]) subject = subject.replace(mailing_list.clean_subject, '') query = models.MailingList.all() mailing_list = query.get() processed_subject = _process_string(subject) processed_body = _process_string(body) email_date = email.utils.parsedate_tz(incoming_msg.date) msg = models.Message(mailing_list=mailing_list, subject=subject, processed_body=processed_body, processed_subject=processed_subject, sender=db.Email(sender), original=db.Text(original), body=db.Text(body), spam=False) if email_date: msg.created = datetime.datetime(*email_date[:6]) - datetime.timedelta( seconds=email_date[-1]) # We now predict the type with Google Predict API credentials = StorageByKeyName(models.Credentials, "key_for_prediction_credentials", 'credentials').get() logging.info('CREDENTIALS: ' + str(credentials)) model = django_settings.GOOGLE_PREDICTION_MODEL if credentials: # Make the Google Prediction API call query = '"' + processed_subject + ' ' + processed_body + '"' [prediction, scores] = google_prediction.Predict(credentials, model, query) msg.prediction = prediction msg.scores = scores msg.put() user_address = '*****@*****.**' chat_message_sent = False msg = "Message '%s' from: %s\nPrediction: %s\n%s" % ( msg.key().id(), incoming_msg.sender, msg.prediction, msg.subject) status_code = xmpp.send_message(user_address, msg) chat_message_sent = (status_code == xmpp.NO_ERROR) if not chat_message_sent: logging.error("Unable to send XMPP message: %s" % msg)