README
¶
This helper is a stand-alone module to help get you started consuming and processing Inbound Parse data.
Table of Contents
Example Usage
package main
import (
"fmt"
"log"
"net/http"
"github.com/sendgrid/sendgrid-go/helpers/inbound"
)
func inboundHandler(response http.ResponseWriter, request *http.Request) {
parsedEmail, err := Parse(request)
if err != nil {
log.Fatal(err)
}
fmt.Print(parsedEmail.Headers["From"])
for filename, contents := range parsedEmail.Attachments {
// Do something with an attachment
handleAttachment(filename, contents)
}
for section, body := range parsedEmail.Body {
// Do something with the email body
handleEmail(body)
}
// Twilio SendGrid needs a 200 OK response to stop POSTing
response.WriteHeader(http.StatusOK)
}
func main() {
http.HandleFunc("/inbound", inboundHandler)
if err := http.ListenAndServe(":8000", nil); err != nil {
log.Fatalln("Error")
}
}
Testing the Source Code
Tests are located in the helpers/inbound folder:
Learn about testing this code here.
Contributing
If you would like to contribute to this project, please see our contributing guide. Thanks!
Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type EmailAttachment ¶
type EmailAttachment struct {
File multipart.File `json:"-"`
Filename string `json:"filename"`
Size int64 `json:"-"`
ContentType string `json:"type"`
}
EmailAttachment defines information related to an email attachment
type ParsedEmail ¶
type ParsedEmail struct {
// Header values are raw and not pre-processed by SendGrid. They may change depending on the email client. Use carefully
Headers map[string]string
// Please see https://docs.sendgrid.com/for-developers/parsing-email/setting-up-the-inbound-parse-webhook to see the available fields in the email headers
// all fields listed there are available within the headers map except for text which lives in the TextBody field
ParsedValues map[string]string
// Primary email body parsed with \n. A common approach is to Split by the \n to bring every line of the email into a string array
TextBody string
// Envelope expresses the exact email address that the email was addressed to and the exact email address it was from, without extra characters
Envelope struct {
From string `json:"from"`
To []string `json:"to"`
}
// attachments have been fully parsed to include the filename, size, content type and actual file for uploading or processing
ParsedAttachments map[string]*EmailAttachment
// Raw only
Attachments map[string][]byte
// accessed with text/html and text/plain. text/plain is always parsed to the TextBody field
Body map[string]string
// contains filtered or unexported fields
}
ParsedEmail defines a multipart parsed email Body and Attachments are only populated if the Raw option is checked on the SendGrid inbound configuration and are named for backwards compatability
Example (ParseHeaders) ¶
headers := `
Foo: foo
Bar: baz
`
email := ParsedEmail{
Headers: make(map[string]string),
Body: make(map[string]string),
Attachments: make(map[string][]byte),
rawRequest: nil,
}
email.parseHeaders(headers)
fmt.Println(email.Headers["Foo"])
fmt.Println(email.Headers["Bar"])
Output: foo baz
Example (ParseRawEmail) ¶
rawEmail := `
To: test@example.com
From: example@example.com
Subject: Test Email
Content-Type: multipart/mixed; boundary=TwiLIo
--TwiLIo
Content-Type: text/plain; charset=UTF-8
Hello Twilio SendGrid!
--TwiLIo
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
<html><body><strong>Hello Twilio SendGrid!</body></html>
--TwiLIo--
`
email := ParsedEmail{
Headers: make(map[string]string),
Body: make(map[string]string),
Attachments: make(map[string][]byte),
rawRequest: nil,
}
if err := email.parseRawEmail(rawEmail); err != nil {
log.Fatal(err)
}
for key, value := range email.Headers {
fmt.Println(key, value)
}
fmt.Println(email.Body["text/plain; charset=UTF-8"])
Output: To test@example.com From example@example.com Subject Test Email Content-Type multipart/mixed; boundary=TwiLIo Hello Twilio SendGrid!
func Parse ¶
func Parse(request *http.Request) (*ParsedEmail, error)
Parse parses an email using Go's multipart parser and populates the headers, and body This method skips processing the attachment file and is therefore more performant
func ParseWithAttachments ¶
func ParseWithAttachments(request *http.Request) (*ParsedEmail, error)
ParseWithAttachments parses an email using Go's multipart parser and populates the headers, body and processes attachments
func (*ParsedEmail) Validate ¶
func (email *ParsedEmail) Validate() error
Validate validates the DKIM and SPF scores to ensure that the email client and address was not spoofed
Source Files