コード例 #1
0
ファイル: messages_test.go プロジェクト: adrianlop/dex
func TestGetStoredMessage(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	id, err := findStoredMessageID(mg) // somehow...
	if err != nil {
		t.Fatal(err)
	}

	// First, get our stored message.
	msg, err := mg.GetStoredMessage(id)
	if err != nil {
		t.Fatal(err)
	}
	fields := map[string]string{
		"       From": msg.From,
		"     Sender": msg.Sender,
		"    Subject": msg.Subject,
		"Attachments": fmt.Sprintf("%d", len(msg.Attachments)),
		"    Headers": fmt.Sprintf("%d", len(msg.MessageHeaders)),
	}
	for k, v := range fields {
		fmt.Printf("%13s: %s\n", k, v)
	}

	// We're done with it; now delete it.
	err = mg.DeleteStoredMessage(id)
	if err != nil {
		t.Fatal(err)
	}
}
コード例 #2
0
func RunApplication() {
	config := CreateConfigFromEnv()

	PrintConfig(config)

	mg := mailgun.NewMailgun(config.Domain, config.ApiKey, "")

	StartHttpServer(mg, config)
}
コード例 #3
0
ファイル: stats_test.go プロジェクト: 9uuso/mailgun-go
func TestDeleteTag(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	err := mg.DeleteTag("newsletter")
	if err != nil {
		t.Fatal(err)
	}
}
コード例 #4
0
ファイル: messages_test.go プロジェクト: adrianlop/dex
func TestSendMGMIME(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	m := mg.NewMIMEMessage(ioutil.NopCloser(strings.NewReader(exampleMime)), toUser)
	msg, id, err := mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("TestSendMIME:MSG(" + msg + "),ID(" + id + ")")
}
コード例 #5
0
ファイル: messages_test.go プロジェクト: adrianlop/dex
func TestSendLegacyPlain(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	publicApiKey := reqEnv(t, "MG_PUBLIC_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, publicApiKey)
	m := mailgun.NewMessage(fromUser, exampleSubject, exampleText, toUser)
	msg, id, err := mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("TestSendPlain:MSG(" + msg + "),ID(" + id + ")")
}
コード例 #6
0
ファイル: messages_test.go プロジェクト: adrianlop/dex
func TestSendMGPlainAt(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	publicApiKey := reqEnv(t, "MG_PUBLIC_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, publicApiKey)
	m := mg.NewMessage(fromUser, exampleSubject, exampleText, toUser)
	m.SetDeliveryTime(time.Now().Add(5 * time.Minute))
	msg, id, err := mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("TestSendPlainAt:MSG(" + msg + "),ID(" + id + ")")
}
コード例 #7
0
ファイル: bounces_test.go プロジェクト: 9uuso/mailgun-go
func TestGetBounces(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	n, bounces, err := mg.GetBounces(-1, -1)
	if err != nil {
		t.Fatal(err)
	}
	if n > 0 {
		t.Fatal("Expected no bounces for what should be a clean domain.")
	}
	if n != len(bounces) {
		t.Fatalf("Expected length of bounces %d to equal returned length %d", len(bounces), n)
	}
}
コード例 #8
0
ファイル: mailgun.go プロジェクト: Tecsisa/dex
func (cfg MailgunEmailerConfig) Emailer(fromAddr string) (Emailer, error) {
	from := cfg.FromAddr
	if from == "" {
		from = fromAddr
	}

	if from == "" {
		return nil, errors.New(`missing "from" field in email config`)
	}
	mg := mailgun.NewMailgun(cfg.Domain, cfg.PrivateAPIKey, cfg.PublicAPIKey)
	return &mailgunEmailer{
		mg:   mg,
		from: from,
	}, nil
}
コード例 #9
0
ファイル: mailgun.go プロジェクト: markhayden/go-go-mailman
// sendWithMailgun handles the main send and logging logic for any single email deploy
func (c *Client) sendWithMailgun() (string, error) {
	var err error

	c.Body, err = c.prepareTmpl()
	if err != nil {
		return "", err
	}

	gun := mg.NewMailgun(Conf["mailgun"]["domain"], Conf["mailgun"]["secret"], Conf["mailgun"]["public"])

	// override the http client
	client := urlfetch.Client(c.context)
	gun.SetClient(client)

	// generate mailgun message
	message := mg.NewMessage(fmt.Sprintf("%s <%s>", Conf["default"]["fromname"], Conf["default"]["fromemail"]), c.Subject, c.Body, c.Recipient[0].Render)
	message.SetHtml(strings.Replace(c.Body, "\\", "", -1))

	// add additional recipients
	for k, v := range c.Recipient {
		if k > 0 {
			err := message.AddRecipient(v.Render)
			if err != nil {
				c.context.Errorf("Could not append [%s] as Mailgun recipient: %v", v.Render, err)
				return "", err
			}
		}
	}

	// send the email
	_, id, err := gun.Send(message)
	if err != nil {
		c.context.Errorf("Error: %v", err)
		return "", err
	}

	if Conf["default"]["logmessages"] == "true" {
		// if the id is not empty then add to the message log
		if id != "" {
			_, logErr := c.addMessageLog()
			if logErr != nil {
				c.context.Errorf("Failed to add message to log: %v", logErr)
			}
		}
	}

	return id, err
}
コード例 #10
0
ファイル: notify.go プロジェクト: ckpt/backend-services
func NotifyUser(name, email, subject, message string) {
	fmt.Printf("Notifying %s with subject:\n", email)
	fmt.Printf("%s\n", subject)

	mailto := fmt.Sprintf("%s <%s>", name, email)
	gun := mailgun.NewMailgun("mail.ckpt.no", os.Getenv("CKPT_MAILGUN_KEY"), "pubkey-b3e133632123a0da24d1e2c5842039b6")
	m := mailgun.NewMessage("CKPT <*****@*****.**>", subject, message, mailto)
	m.AddHeader("Content-Type", "text/plain; charset=\"utf-8\"")
	response, id, err := gun.Send(m)

	if err != nil {
		fmt.Printf("Error:\n%+v\n", err.Error())
	}
	fmt.Printf("Response ID: %s\n", id)
	fmt.Printf("Message from server: %s\n", response)
}
コード例 #11
0
ファイル: messages_test.go プロジェクト: adrianlop/dex
func TestSendMGBatchFailRecipients(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	m := mg.NewMessage(fromUser, exampleSubject, exampleText+"Batch\n")
	for i := 0; i < mailgun.MaxNumberOfRecipients; i++ {
		m.AddRecipient("") // We expect this to indicate a failure at the API
	}
	err := m.AddRecipientAndVariables(toUser, nil)
	if err == nil {
		// If we're here, either the SDK didn't send the message,
		// OR the API didn't check for empty To: headers.
		t.Fatal("Expected to fail!!")
	}
}
コード例 #12
0
ファイル: messages_test.go プロジェクト: adrianlop/dex
func TestSendMGTag(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	publicApiKey := reqEnv(t, "MG_PUBLIC_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, publicApiKey)
	m := mg.NewMessage(fromUser, exampleSubject, exampleText+"Tags Galore!\n", toUser)
	m.AddTag("FooTag")
	m.AddTag("BarTag")
	m.AddTag("BlortTag")
	msg, id, err := mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("TestSendTag:MSG(" + msg + "),ID(" + id + ")")
}
コード例 #13
0
ファイル: credentials_test.go プロジェクト: 9uuso/mailgun-go
func TestGetCredentials(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	n, cs, err := mg.GetCredentials(mailgun.DefaultLimit, mailgun.DefaultSkip)
	if err != nil {
		t.Fatal(err)
	}
	tw := &tabwriter.Writer{}
	tw.Init(os.Stdout, 2, 8, 2, ' ', 0)
	fmt.Fprintf(tw, "Login\tCreated At\t\n")
	for _, c := range cs {
		fmt.Fprintf(tw, "%s\t%s\t\n", c.Login, c.CreatedAt)
	}
	tw.Flush()
	fmt.Printf("%d credentials listed out of %d\n", len(cs), n)
}
コード例 #14
0
func setup(t *testing.T) (mailgun.Mailgun, string) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")

	address := fmt.Sprintf("list5@%s", domain)
	_, err := mg.CreateList(mailgun.List{
		Address:     address,
		Name:        address,
		Description: "TestMailingListMembers-related mailing list",
		AccessLevel: mailgun.Members,
	})
	if err != nil {
		t.Fatal(err)
	}
	return mg, address
}
コード例 #15
0
ファイル: bounces_test.go プロジェクト: 9uuso/mailgun-go
func TestGetSingleBounce(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	exampleEmail := fmt.Sprintf("baz@%s", domain)
	_, err := mg.GetSingleBounce(exampleEmail)
	if err == nil {
		t.Fatal("Did not expect a bounce to exist")
	}
	ure, ok := err.(*mailgun.UnexpectedResponseError)
	if !ok {
		t.Fatal("Expected UnexpectedResponseError")
	}
	if ure.Actual != 404 {
		t.Fatalf("Expected 404 response code; got %d", ure.Actual)
	}
}
コード例 #16
0
ファイル: messages_test.go プロジェクト: adrianlop/dex
func TestSendMGBatchRecipientVariables(t *testing.T) {
	toUser := reqEnv(t, "MG_EMAIL_TO")
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	m := mg.NewMessage(fromUser, exampleSubject, templateText)
	err := m.AddRecipientAndVariables(toUser, map[string]interface{}{
		"name":  "Joe Cool Example",
		"table": 42,
	})
	if err != nil {
		t.Fatal(err)
	}
	_, _, err = mg.Send(m)
	if err != nil {
		t.Fatal(err)
	}
}
コード例 #17
0
ファイル: stats_test.go プロジェクト: 9uuso/mailgun-go
func TestGetStats(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")

	totalCount, stats, err := mg.GetStats(-1, -1, nil, "sent", "opened")
	if err != nil {
		t.Fatal(err)
	}

	fmt.Printf("Total Count: %d\n", totalCount)
	tw := tabwriter.NewWriter(os.Stdout, 2, 8, 2, ' ', tabwriter.AlignRight)
	fmt.Fprintf(tw, "Id\tEvent\tCreatedAt\tTotalCount\t\n")
	for _, stat := range stats {
		fmt.Fprintf(tw, "%s\t%s\t%s\t%d\t\n", stat.Id, stat.Event, stat.CreatedAt, stat.TotalCount)
	}
	tw.Flush()
}
コード例 #18
0
ファイル: unsubscribes_test.go プロジェクト: 9uuso/mailgun-go
func TestCreateDestroyUnsubscription(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	email := reqEnv(t, "MG_EMAIL_ADDR")
	mg := mailgun.NewMailgun(domain, apiKey, "")

	// Create unsubscription record
	err := mg.Unsubscribe(email, "*")
	if err != nil {
		t.Fatal(err)
	}

	// Destroy the unsubscription record
	err = mg.RemoveUnsubscribe(email)
	if err != nil {
		t.Fatal(err)
	}
}
コード例 #19
0
ファイル: unsubscribes_test.go プロジェクト: 9uuso/mailgun-go
func TestGetUnsubscribes(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	n, us, err := mg.GetUnsubscribes(mailgun.DefaultLimit, mailgun.DefaultSkip)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Printf("Received %d out of %d unsubscribe records.\n", len(us), n)
	if len(us) > 0 {
		tw := &tabwriter.Writer{}
		tw.Init(os.Stdout, 2, 8, 2, ' ', 0)
		fmt.Fprintln(tw, "ID\tAddress\tCreated At\tTag\t")
		for _, u := range us {
			fmt.Fprintf(tw, "%s\t%s\t%s\t%s\t\n", u.ID, u.Address, u.CreatedAt, u.Tag)
		}
		tw.Flush()
	}
}
コード例 #20
0
ファイル: mailgun.go プロジェクト: vijaykanthm28/vertice
func (m *mailgunner) Send(msg string, sender string, subject string, to string) error {
	if len(strings.TrimSpace(sender)) <= 0 {
		sender = "Kishore CEO <*****@*****.**>"
	}
	mg := mailgun.NewMailgun(m.domain, m.api_key, "")
	g := mailgun.NewMessage(
		sender,
		subject,
		"You are in !",
		to,
	)
	g.SetHtml(msg)
	g.SetTracking(true)
	_, id, err := mg.Send(g)
	if err != nil {
		return err
	}
	log.Infof("Mailgun sent %s", id)
	return nil
}
コード例 #21
0
ファイル: mailgun.go プロジェクト: vijaykanthm28/libgo
func (m *mailgunner) Send(msg string, sender string, subject string, to string) error {
	if len(strings.TrimSpace(sender)) <= 0 {
		sender = m.sender
	}
	mg := mailgun.NewMailgun(m.domain, m.api_key, "")
	g := mailgun.NewMessage(
		sender,
		subject,
		"You are in !",
		to,
	)
	g.SetHtml(msg)
	g.SetTracking(false)
	//g.SetTrackingClicks(false)
	//g.SetTrackingOpens(false)
	_, id, err := mg.Send(g)
	if err != nil {
		return err
	}
	log.Infof("Mailgun sent %s", id)
	return nil
}
コード例 #22
0
ファイル: credentials_test.go プロジェクト: 9uuso/mailgun-go
func TestCreateDeleteCredentials(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	randomPassword := randomString(16, "pw")
	randomID := randomString(16, "usr")
	randomLogin := fmt.Sprintf("%s@%s", randomID, domain)

	err := mg.CreateCredential(randomLogin, randomPassword)
	if err != nil {
		t.Fatal(err)
	}

	err = mg.ChangeCredentialPassword(randomID, randomString(16, "pw2"))
	if err != nil {
		t.Fatal(err)
	}

	err = mg.DeleteCredential(randomID)
	if err != nil {
		t.Fatal(err)
	}
}
コード例 #23
0
ファイル: mailgun.go プロジェクト: adrianlop/dex
func (cfg MailgunEmailerConfig) Emailer() (Emailer, error) {
	mg := mailgun.NewMailgun(cfg.Domain, cfg.PrivateAPIKey, cfg.PublicAPIKey)
	return &mailgunEmailer{
		mg: mg,
	}, nil
}
コード例 #24
0
ファイル: bounces_test.go プロジェクト: 9uuso/mailgun-go
func TestAddDelBounces(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")

	// Compute an e-mail address for our domain.

	exampleEmail := fmt.Sprintf("baz@%s", domain)

	// First, basic sanity check.
	// Fail early if we have bounces for a fictitious e-mail address.

	n, _, err := mg.GetBounces(-1, -1)
	if err != nil {
		t.Fatal(err)
	}
	if n > 0 {
		t.Fatal("Expected no bounces for what should be a clean domain.")
	}

	bounce, err := mg.GetSingleBounce(exampleEmail)
	if err == nil {
		t.Fatalf("Expected no bounces for %s", exampleEmail)
	}

	// Add the bounce for our address.

	err = mg.AddBounce(exampleEmail, "550", "TestAddDelBounces-generated error")
	if err != nil {
		t.Fatal(err)
	}

	// We should now have one bounce listed when we query the API.

	n, bounces, err := mg.GetBounces(-1, -1)
	if err != nil {
		t.Fatal(err)
	}
	if n != 1 {
		t.Fatal("Expected one bounce for this domain.")
	}
	if bounces[0].Address != exampleEmail {
		t.Fatalf("Expected bounce for address %s; got %s", exampleEmail, bounces[0].Address)
	}

	bounce, err = mg.GetSingleBounce(exampleEmail)
	if err != nil {
		t.Fatal(err)
	}
	if bounce.CreatedAt == "" {
		t.Fatalf("Expected at least one bounce for %s", exampleEmail)
	}

	// Delete it.  This should put us back the way we were.

	err = mg.DeleteBounce(exampleEmail)
	if err != nil {
		t.Fatal(err)
	}

	// Make sure we're back to the way we were.

	n, _, err = mg.GetBounces(-1, -1)
	if err != nil {
		t.Fatal(err)
	}
	if n > 0 {
		t.Fatal("Expected no bounces for what should be a clean domain.")
	}

	_, err = mg.GetSingleBounce(exampleEmail)
	if err == nil {
		t.Fatalf("Expected no bounces for %s", exampleEmail)
	}
}
コード例 #25
0
ファイル: mailgun.go プロジェクト: gregory90/go-mailgun
func Init(mailgunDomain string, mailgunPrivateKey string, mailgunPublicKey string) {
	gun = mailgun.NewMailgun(mailgunDomain, mailgunPrivateKey, mailgunPublicKey)
}
コード例 #26
0
ファイル: main.go プロジェクト: cinnabardk/exp
	// "github.com/armon/go-radix"
	// "github.com/miekg/radix"
	// "github.com/manveru/trie"
	// "github.com/IanLewis/codekata" // exercise
	// Single word search:
	// "github.com/AlasdairF/Tokenize"
	// "github.com/typeflow/typeflow-go"
	// "github.com/blevesearch/bleve/search"
	// "github.com/typerandom/cleo"
	// "github.com/sajari/fuzzy"
	// "github.com/smartystreets/mafsa"
	"os"
	"runtime"
)

var gun = mailgun.NewMailgun("aabenhave.dk", "key-2dcm94f8dttfm4k4xid3y8x2c8et-op6", "pubkey-3c1amkiwdizjhoa-cqnkrlvylm0pmiq4")

func main() {
	c := runtime.NumCPU()
	runtime.GOMAXPROCS(c)
	os.Mkdir("data", 0777)
	e.LogInit()
	testRandom()
	test := Test{}
	test.Codex()
}

func initExp() {
	e.InfoLog.Println("Init various")
	e.InfoLog.Println(conv.String(74534537787))
	test := Test{}
コード例 #27
0
func TestMailingLists(t *testing.T) {
	domain := reqEnv(t, "MG_DOMAIN")
	apiKey := reqEnv(t, "MG_API_KEY")
	mg := mailgun.NewMailgun(domain, apiKey, "")
	listAddr := fmt.Sprintf("list2@%s", domain)
	protoList := mailgun.List{
		Address:     listAddr,
		Name:        "List1",
		Description: "A list created by an acceptance test.",
		AccessLevel: mailgun.Members,
	}

	var countLists = func() int {
		total, _, err := mg.GetLists(mailgun.DefaultLimit, mailgun.DefaultSkip, "")
		if err != nil {
			t.Fatal(err)
		}
		return total
	}

	startCount := countLists()

	_, err := mg.CreateList(protoList)
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		err = mg.DeleteList(listAddr)
		if err != nil {
			t.Fatal(err)
		}

		newCount := countLists()
		if newCount != startCount {
			t.Fatalf("Expected %d lists defined; got %d", startCount, newCount)
		}
	}()

	newCount := countLists()
	if newCount <= startCount {
		t.Fatalf("Expected %d lists defined; got %d", startCount+1, newCount)
	}

	theList, err := mg.GetListByAddress(listAddr)
	if err != nil {
		t.Fatal(err)
	}
	protoList.CreatedAt = theList.CreatedAt // ignore this field when comparing.
	if theList != protoList {
		t.Fatalf("Unexpected list descriptor: Expected [%#v], Got [%#v]", protoList, theList)
	}

	_, err = mg.UpdateList(listAddr, mailgun.List{
		Description: "A list whose description changed",
	})
	if err != nil {
		t.Fatal(err)
	}

	theList, err = mg.GetListByAddress(listAddr)
	if err != nil {
		t.Fatal(err)
	}
	newList := protoList
	newList.Description = "A list whose description changed"
	if theList != newList {
		t.Fatalf("Expected [%#v], Got [%#v]", newList, theList)
	}
}
コード例 #28
0
ファイル: crawl.go プロジェクト: davidpfahler/unicrawl
func main() {
	domain := flag.String("domain", "", "mailgun domain")
	privateKey := flag.String("private-key", "", "secret mailgun api key")
	publicKey := flag.String("public-key", "", "mailgun public api key")
	dry := flag.Bool("dry", false, "do not update cache & only print to stdout (no e-mail)")
	verbose := flag.Bool("verbose", false, "Print detailed output per monitored url.")
	flag.Parse()

	if *domain == "" || *privateKey == "" || *publicKey == "" {
		log.Fatalln("domain, private-key and public-key flags are required")
	}

	gun := m.NewMailgun(*domain, *privateKey, *publicKey)

	urls := loadUrls()
	for _, url := range urls {
		body, err := requestURL(url)
		if err != nil {
			log.Println("Skipped URL because of error requesting it:", url)
			continue
		}
		filename := getExecFolder() + "/cache/" + getMD5Hash(url) + ".html"

		cached, err := ioutil.ReadFile(filename)
		if err != nil {
			if *dry == false {
				updateCache(filename, body)
			}

			switch err := err.(type) {
			case *os.PathError:
				fmt.Printf("This URL will now be monitored: %s\n\n", url)
			default:
				log.Fatalf("Fatal errors type %T\n", err)
			}
		} else {
			if reflect.DeepEqual(cached, body) {
				if *verbose {
					fmt.Printf("This URL didn't change: %s\n\n", url)
				}
			} else {
				cachedDoc := getGoqueryDoc(cached)
				currentDoc := getGoqueryDoc(body)
				cachedContent, _ := cachedDoc.Find("#content").Html()
				currentContent, _ := currentDoc.Find("#content").Html()

				if cachedContent == currentContent {
					if *verbose {
						fmt.Println("The website changed, but the content stayed the same.")
					}
				} else {
					cachedText, _ := html2text.FromString(cachedContent)
					currentText, _ := html2text.FromString(currentContent)
					diff := difflib.Diff(strings.Split(cachedText, "\n"), strings.Split(currentText, "\n"))

					msg := createMessage(diff, url)
					htmlMsg := createHTMLMessage(diff, url)
					if *dry {
						fmt.Println(msg)
					} else {
						sendEmails(gun, msg, htmlMsg)
					}
				}
				if *dry == false {
					updateCache(filename, body)
				}
			}
		}
	}
}