smtp2go

README

SMTP2GO API

Go wrapper around the SMTP2GO /email/send API endpoint.

Fork of smtp2go-oss/smtp2go-go to add support for file attachments.

Installation

go get github.com/AleksiAlho/smtp2go-go

Add the import in your source file

import "github.com/AleksiAlho/smtp2go-go"

Usage

Sign up for a free account here and once logged in navigate to the Settings -> Api Keys page, create a new API key and make sure the /email/send endpoint is enabled:

Once you have an API key you need to export it into the environment where your Go application is going to be executed, this can be done on the terminal like so:

`$ export SMTP2GO_API_KEY="<your_API_key>"`

Or alternatively you can set it in code via

import "os"
os.Setenv("SMTP2GO_API_KEY", "<your_API_key>")

Then sending mail is as simple as:

package main

import (
	"fmt"
	"github.com/AleksiAlho/smtp2go-go"
)

func main() {

	email := smtp2go.Email{
		From: "Matt <matt@example.com>",
		To: []string{
			"Dave <dave@example.com>",
		},
		Subject:  "Trying out SMTP2GO",
		TextBody: "Test Message",
		HtmlBody: "<h1>Test Message</h1>",
	}
	res, err := smtp2go.Send(&email)
	if err != nil {
		fmt.Printf("An Error Occurred: %s", err)
	}
	fmt.Printf("Sent Successfully: %s", res)
}

You can also send Asynchronously:

package main

import (
	"fmt"
	"github.com/AleksiAlho/smtp2go-go"
)

func main() {

	email := smtp2go.Email{
		From: "Matt <matt@example.com>",
		To: []string{
			"Dave <dave@example.com>",
		},
		Subject:  "Trying out SMTP2GO",
		TextBody: "Test Message",
		HtmlBody: "<h1>Test Message</h1>",
	}

	var c chan *smtp2go.SendAsyncResult = smtp2go.SendAsync(&email)
	res := <-c
	if res.Error != nil {
		fmt.Printf("An Error Occurred: %s", res.Error)
	}
	fmt.Printf("Sent Successfully: %s", res.Result)
}

Development

Clone repo. Run tests with go test.

Contributing

Bug reports and pull requests are welcome on GitHub here

License

The package is available as open source under the terms of the MIT License.

Documentation

Index

• func SendAsync(e *Email) chan *SendAsyncResult
• type Attachment
• type Email
• type EndpointError
  • func (f EndpointError) Error() string
• type IncorrectAPIKeyFormatError
  • func (f IncorrectAPIKeyFormatError) Error() string
• type InvalidJSONError
  • func (f InvalidJSONError) Error() string
• type MissingAPIKeyError
  • func (f MissingAPIKeyError) Error() string
• type MissingRequiredFieldError
  • func (f MissingRequiredFieldError) Error() string
• type RequestError
  • func (f RequestError) Error() string
• type SendAsyncResult
• type Smtp2goApiResult
  • func Send(e *Email) (*Smtp2goApiResult, error)
• type Smtp2goApiResult_Data
• type Smtp2goApiResult_FieldFailure

Functions

func SendAsync

func SendAsync(e *Email) chan *SendAsyncResult

SendAsync asynchronous send function

Types

type Attachment

type Attachment struct {
	Filename string `json:"filename"`
	Fileblob string `json:"fileblob"`
	Mimetype string `json:"mimetype"`
}

Attachment struct to hold information about an attachment

type Email

type Email struct {
	From         string       `json:"sender"`
	To           []string     `json:"to"`
	Subject      string       `json:"subject"`
	TextBody     string       `json:"text_body"`
	HtmlBody     string       `json:"html_body"`
	TemplateID   string       `json:"template_id"`
	TemplateData interface{}  `json:"template_data"`
	Attachments  []Attachment `json:"attachments"`
}

Email holds the data used to send the email

type EndpointError

type EndpointError struct {
	// contains filtered or unexported fields
}

EndpointError error during endpoint call

func (EndpointError) Error

func (f EndpointError) Error() string

Error implementation of Error on EndpointError

type IncorrectAPIKeyFormatError

type IncorrectAPIKeyFormatError struct {
	// contains filtered or unexported fields
}

IncorrectAPIKeyFormatError error for bad api key

func (IncorrectAPIKeyFormatError) Error

func (f IncorrectAPIKeyFormatError) Error() string

Error implementation of Error on IncorrectAPIKeyFormatError

type InvalidJSONError

type InvalidJSONError struct {
	// contains filtered or unexported fields
}

InvalidJSONError error due to bad json

func (InvalidJSONError) Error

func (f InvalidJSONError) Error() string

Error implementation of Error on InvalidJSONError

type MissingAPIKeyError

type MissingAPIKeyError string

MissingAPIKeyError error for missing api key

func (MissingAPIKeyError) Error

func (f MissingAPIKeyError) Error() string

Error implementation of Error on MissingAPIKeyError

type MissingRequiredFieldError

type MissingRequiredFieldError struct {
	// contains filtered or unexported fields
}

MissingRequiredFieldError error fro missing field

func (MissingRequiredFieldError) Error

func (f MissingRequiredFieldError) Error() string

Error implementation of Error on MissingRequiredFieldError

type RequestError

type RequestError struct {
	// contains filtered or unexported fields
}

RequestError error during request

func (RequestError) Error

func (f RequestError) Error() string

Error implementation of Error on RequestError

type SendAsyncResult

type SendAsyncResult struct {
	Error  error
	Result *Smtp2goApiResult
}

SendAsyncResult result struct from async send call

type Smtp2goApiResult

type Smtp2goApiResult struct {
	RequestId string                `json:"request_id"`
	Data      Smtp2goApiResult_Data `json:"data"`
}

Smtp2goApiResult response payload from the API

func Send

func Send(e *Email) (*Smtp2goApiResult, error)

Send synchronous send function

type Smtp2goApiResult_Data

type Smtp2goApiResult_Data struct {
	Error                 string                        `json:"error"`
	ErrorCode             string                        `json:"error_code"`
	FieldValidationErrors Smtp2goApiResult_FieldFailure `json:"field_validation_errors"`
}

Smtp2goApiResult_Data struct that holds the response data from the API

type Smtp2goApiResult_FieldFailure

type Smtp2goApiResult_FieldFailure struct {
	FieldName string `json:"fieldname"`
	Message   string `json:"message"`
}

Smtp2goApiResult_FieldFailure if fields failed on the api side this will hold the information