Package tosend provides a Go client for the ToSend email API.
Package mailbreeze provides a Go client for the MailBreeze email platform API.
Package lettermint provides the official Go SDK for the Lettermint email API.
Package tempmailchecker provides a Go client for the TempMailChecker API.
Package sendamatic provides a Go client library for the Sendamatic email delivery API.
Package email provides a Starlark module that sends email through the Resend API (https://resend.com).
Package sendlix provides a comprehensive Go SDK for the Sendlix email service API.
Package ses provides the client and types for making API requests to Amazon Simple Email Service.
Package gohog is a client library to interact with and consume mailhog's api https://github.com/mailhog/MailHog mailhog is very useful when testing email integration
Package gohog is a client library to interact with and consume mailhog's api https://github.com/mailhog/MailHog mailhog is very useful when testing email integration
Package gorest - Go RESTful API starter kit with Gin, JWT, GORM (MySQL, PostgreSQL, SQLite), Redis, Mongo, 2FA, email verification, password recovery
Package sesv2 provides the API client, operations, and parameter types for Amazon Simple Email Service.
Package email provides a Starlark module that sends email using Resend API.
Package email provides a Starlark module that sends email using Resend API.
Package gmail provides a lightweight API to send emails using the google SMTP server.
* @Author: lihuan * @Date: 2021-12-13 20:14:22 * @LastEditors: lihuan * @LastEditTime: 2021-12-13 22:20:16 * @Email: 17719495105@163.com
Package mailyak provides a simple interface for generating MIME compliant emails, and optionally sending them over SMTP. Both plain-text and HTML email body content is supported, and their types implement io.Writer allowing easy composition directly from templating engines, etc. Attachments are fully supported including inline attachments, with anything that implements io.Reader suitable as a source (like files on disk, in-memory buffers, etc). The raw MIME content can be retrieved using MimeBuf(), typically used with an API service such as Amazon SES that does not require using an SMTP interface. MailYak supports both plain-text SMTP (which is automatically upgraded to a secure connection with STARTTLS if supported by the SMTP server) and explicit TLS connections.
Package gomail provides a simple interface to compose emails and to mail them efficiently. More info on Github: https://github.com/go-gomail/gomail A daemon that listens to a channel and sends all incoming messages. Efficiently send a customized newsletter to a list of recipients. Send an email using a local SMTP server. Send an email using an API or postfix.
Package postmark provides a Go client for the Postmark API, covering both administrative operations (creating, reading, updating, listing, and deleting Postmark Servers) and email-sending operations (single, batch, template, bulk).
Package hubspot is a SDK client library for HubSpot's API Example usage: package main import "github.com/simplyhey/hubspot" func main() { // Create client object with config from environment variables (HUBSPOT_API_HOST, HUBSPOT_API_KEY, HUBSPOT_OAUTH_TOKEN) c := hubspot.NewClient(hubspot.NewClientConfig()) // Create new contact data := hubspot.ContactsRequest{ hubspot.Properties: []hubspot.Property{ hubspot.Property{ Property: "email", Value: "contact@example.com", }, hubspot.Property{ Property: "firstname", Value: "Contact", }, hubspot.Property{ Property: "lastname", Value: "Example", }, }, } r, err := c.Contacts().Create(data) if err != nil { log.Fatal(err) } // Get contact by email contact, err = c.Contacts().GetByEmail("contact@example.com") if err != nil { log.Fatal(err) } // Print contact object fmt.Printf("%+v", contact) } Configuration Package can be configured using environment variables for default initialization.
Package hubspot is a SDK client library for HubSpot's API Example usage: package main import "github.com/simplycubed/hubspot" func main() { // Create client object with config from environment variables (HUBSPOT_API_HOST, HUBSPOT_API_KEY, HUBSPOT_OAUTH_TOKEN) c := hubspot.NewClient(hubspot.NewClientConfig()) // Create new contact data := hubspot.ContactsRequest{ hubspot.Properties: []hubspot.Property{ hubspot.Property{ Property: "email", Value: "contact@example.com", }, hubspot.Property{ Property: "firstname", Value: "Contact", }, hubspot.Property{ Property: "lastname", Value: "Example", }, }, } r, err := c.Contacts().Create(data) if err != nil { log.Fatal(err) } // Get contact by email contact, err = c.Contacts().GetByEmail("contact@example.com") if err != nil { log.Fatal(err) } // Print contact object fmt.Printf("%+v", contact) } Configuration Package can be configured using environment variables for default initialization.
Package enmime implements a MIME encoding and decoding library. It's built on top of Go's included mime/multipart support where possible, but is geared towards parsing MIME encoded emails. The enmime API has two conceptual layers. The lower layer is a tree of Part structs, representing each component of a decoded MIME message. The upper layer, called an Envelope provides an intuitive way to interact with a MIME message. Calling ReadParts causes enmime to parse the body of a MIME message into a tree of Part objects, each of which is aware of its content type, filename and headers. The content of a Part is available as a slice of bytes via the Content field. If the part was encoded in quoted-printable or base64, it is decoded prior to being placed in Content. If the Part contains text in a character set other than utf-8, enmime will attempt to convert it to utf-8. To locate a particular Part, pass a custom PartMatcher function into the BreadthMatchFirst() or DepthMatchFirst() methods to search the Part tree. BreadthMatchAll() and DepthMatchAll() will collect all Parts matching your criteria. ReadEnvelope returns an Envelope struct. Behind the scenes a Part tree is constructed, and then sorted into the correct fields of the Envelope. The Envelope contains both the plain text and HTML portions of the email. If there was no plain text Part available, the HTML Part will be down-converted using the html2text library1. The root of the Part tree, as well as slices of the inline and attachment Parts are also available. Every MIME Part has its own headers, accessible via the Part.Header field. The raw headers for an Envelope are available in Root.Header. Envelope also provides helper methods to fetch headers: GetHeader(key) will return the RFC 2047 decoded value of the specified header. AddressList(key) will convert the specified address header into a slice of net/mail.Address values. enmime attempts to be tolerant of poorly encoded MIME messages. In situations where parsing is not possible, the ReadEnvelope and ReadParts functions will return a hard error. If enmime is able to continue parsing the message, it will add an entry to the Errors slice on the relevant Part. After parsing is complete, all Part errors will be appended to the Envelope Errors slice. The Error* constants can be used to identify a specific class of error. Please note that enmime parses messages into memory, so it is not likely to perform well with multi-gigabyte attachments. enmime is open source software released under the MIT License. The latest version can be found at https://github.com/jhillyerd/enmime
Package goa provides the runtime support for goa microservices. goa service development begins with writing the *design* of a service. The design is described using the goa language implemented by the github.com/goadesign/goa/design/apidsl package. The `goagen` tool consumes the metadata produced from executing the design language to generate service specific code that glues the underlying HTTP server with action specific code and data structures. The goa package contains supporting functionality for the generated code including basic request and response state management through the RequestData and ResponseData structs, error handling via error classes, middleware support via the Middleware data structure as well as decoding and encoding algorithms. The RequestData and ResponseData structs provides access to the request and response state. goa request handlers also accept a context.Context interface as first parameter so that deadlines and cancelation signals may easily be implemented. The request state exposes the underlying http.Request object as well as the deserialized payload (request body) and parameters (both path and querystring parameters). Generated action specific contexts wrap the context.Context, ResponseData and RequestData data structures. They expose properly typed fields that correspond to the request parameters and body data structure descriptions appearing in the design. The response state exposes the response status and body length as well as the underlying ResponseWriter. Action contexts provide action specific helper methods that write the responses as described in the design optionally taking an instance of the media type for responses that contain a body. Here is an example showing an "update" action corresponding to following design (extract): The action signature generated by goagen is: where UpdateBottleContext is: and implements: The definitions of the Bottle and UpdateBottlePayload data structures are ommitted for brievity. There is one controller interface generated per resource defined via the design language. The interface exposes the controller actions. User code must provide data structures that implement these interfaces when mounting a controller onto a service. The controller data structure should include an anonymous field of type *goa.Controller which takes care of implementing the middleware handling. A goa middleware is a function that takes and returns a Handler. A Handler is a the low level function which handles incoming HTTP requests. goagen generates the handlers code so each handler creates the action specific context and calls the controller action with it. Middleware can be added to a goa service or a specific controller using the corresponding Use methods. goa comes with a few stock middleware that handle common needs such as logging, panic recovery or using the RequestID header to trace requests across multiple services. The controller action methods generated by goagen such as the Update method of the BottleController interface shown above all return an error value. goa defines an Error struct that action implementations can use to describe the content of the corresponding HTTP response. Errors can be created using error classes which are functions created via NewErrorClass. The ErrorHandler middleware maps errors to HTTP responses. Errors that are instances of the Error struct are mapped using the struct fields while other types of errors return responses with status code 500 and the error message in the body. The goa design language documented in the dsl package makes it possible to attach validations to data structure definitions. One specific type of validation consists of defining the format that a data structure string field must follow. Example of formats include email, data time, hostnames etc. The ValidateFormat function provides the implementation for the format validation invoked from the code generated by goagen. The goa design language makes it possible to specify the encodings supported by the API both as input (Consumes) and output (Produces). goagen uses that information to registed the corresponding packages with the service encoders and decoders via their Register methods. The service exposes the DecodeRequest and EncodeResponse that implement a simple content type negotiation algorithm for picking the right encoder for the "Content-Type" (decoder) or "Accept" (encoder) request header. Package goa standardizes on structured error responses: a request that fails because of an invalid input or an unexpected condition produces a response that contains a structured error. The error data structures returned to clients contains five fields: an ID, a code, a status, a detail and metadata. The ID is unique for the occurrence of the error, it helps correlate the content of the response with the content of the service logs. The code defines the class of error (e.g. "invalid_parameter_type") and the status the corresponding HTTP status (e.g. 400). The detail contains a message specific to the error occurrence. The metadata contains key/value pairs that provide contextual information (name of parameters, value of invalid parameter etc.). Instances of Error can be created via Error Class functions. See http://goa.design/implement/error_handling.html All instance of errors created via a error class implement the ServiceError interface. This interface is leveraged by the error handler middleware to produce the error responses. The code generated by goagen calls the helper functions exposed in this file when it encounters invalid data (wrong type, validation errors etc.) such as InvalidParamTypeError, InvalidAttributeTypeError etc. These methods return errors that get merged with any previously encountered error via the Error Merge method. The helper functions are error classes stored in global variable. This means your code can override their values to produce arbitrary error responses. goa includes an error handler middleware that takes care of mapping back any error returned by previously called middleware or action handler into HTTP responses. If the error was created via an error class then the corresponding content including the HTTP status is used otherwise an internal error is returned. Errors that bubble up all the way to the top (i.e. not handled by the error middleware) also generate an internal error response.
Package mailyak provides a simple interface for generating MIME compliant emails, and optionally sending them over SMTP. Both plain-text and HTML email body content is supported, and their types implement io.Writer allowing easy composition directly from templating engines, etc. Attachments are fully supported (attach anything that implements io.Reader). The raw MIME content can be retrieved using MimeBuf(), typically used with an API service such as Amazon SES that does not require using an SMTP interface.
* * @Author: Aldo Sotolongo * @Date: 2016-07-03T19:43:02-04:30 * @Email: aldenso@gmail.com * @Last modified by: Aldo Sotolongo * @Last modified time: 2016-07-07T09:57:00-04:30 * * @Author: Aldo Sotolongo * @Date: 2016-07-03T19:42:40-04:30 * @Email: aldenso@gmail.com * @Last modified by: Aldo Sotolongo * @Last modified time: 2016-07-06T15:12:24-04:30 * * @Author: Aldo Sotolongo * @Date: 2016-07-03T19:42:53-04:30 * @Email: aldenso@gmail.com * @Last modified by: Aldo Sotolongo * @Last modified time: 2016-07-06T21:54:09-04:30
Package gomail provides a simple interface to compose emails and to mail them efficiently. More info on Github: https://github.com/go-mail/mail A daemon that listens to a channel and sends all incoming messages. Efficiently send a customized newsletter to a list of recipients. Send an email using a local SMTP server. Send an email using an API or postfix.
Package gomail provides a simple interface to compose emails and to mail them efficiently. More info on Github: https://github.com/go-mail/mail A daemon that listens to a channel and sends all incoming messages. Efficiently send a customized newsletter to a list of recipients. Send an email using a local SMTP server. Send an email using an API or postfix.
Package gomailtrain implementing mailtrain API Simple example: api, err := gomailtrain.NewAPI("https://mailtrain.example.com", "token") if err != nil { // handle error } // read all subscribed lists for an email lists, err := api.GetListsByEmail("mail@example.com") if err != nil { // handle error }
Package mailyak provides a simple interface for generating MIME compliant emails, and optionally sending them over SMTP. Both plain-text and HTML email body content is supported, and their types implement io.Writer allowing easy composition directly from templating engines, etc. Attachments are fully supported (attach anything that implements io.Reader). The raw MIME content can be retrieved using MimeBuf(), typically used with an API service such as Amazon SES that does not require using an SMTP interface.