package mailgun import ( "github.com/mbanzon/simplehttp" "strconv" "time" ) // DefaultLimit and DefaultSkip instruct the SDK to rely on Mailgun's reasonable defaults for pagination settings. const ( DefaultLimit = -1 DefaultSkip = -1 ) // Disabled, Tag, and Delete indicate spam actions. // Disabled prevents Mailgun from taking any action on what it perceives to be spam. // Tag instruments the received message with headers providing a measure of its spamness. // Delete instructs Mailgun to just block or delete the message all-together. const ( Tag = "tag" Disabled = "disabled" Delete = "delete" ) // A Domain structure holds information about a domain used when sending mail. // The SpamAction field must be one of Tag, Disabled, or Delete. type Domain struct { CreatedAt string `json:"created_at"` SMTPLogin string `json:"smtp_login"` Name string `json:"name"` SMTPPassword string `json:"smtp_password"` Wildcard bool `json:"wildcard"` SpamAction string `json:"spam_action"` } // DNSRecord structures describe intended records to properly configure your domain for use with Mailgun. // Note that Mailgun does not host DNS records. type DNSRecord struct { Priority string RecordType string `json:"record_type"` Valid string Name string Value string } type domainsEnvelope struct { TotalCount int `json:"total_count"` Items []Domain `json:"items"` } type singleDomainEnvelope struct { Domain Domain `json:"domain"` ReceivingDNSRecords []DNSRecord `json:"receiving_dns_records"` SendingDNSRecords []DNSRecord `json:"sending_dns_records"` } // GetCreatedAt returns the time the domain was created as a normal Go time.Time type. func (d Domain) GetCreatedAt() (t time.Time, err error) { t, err = parseMailgunTime(d.CreatedAt) return } // GetDomains retrieves a set of domains from Mailgun. // // Assuming no error, both the number of items retrieved and a slice of Domain instances. // The number of items returned may be less than the specified limit, if it's specified. // Note that zero items and a zero-length slice do not necessarily imply an error occurred. // Except for the error itself, all results are undefined in the event of an error. func (m *MailgunImpl) GetDomains(limit, skip int) (int, []Domain, error) { r := simplehttp.NewHTTPRequest(generatePublicApiUrl(domainsEndpoint)) if limit != DefaultLimit { r.AddParameter("limit", strconv.Itoa(limit)) } if skip != DefaultSkip { r.AddParameter("skip", strconv.Itoa(skip)) } r.SetBasicAuth(basicAuthUser, m.ApiKey()) var envelope domainsEnvelope err := getResponseFromJSON(r, &envelope) if err != nil { return -1, nil, err } return envelope.TotalCount, envelope.Items, nil } // Retrieve detailed information about the named domain. func (m *MailgunImpl) GetSingleDomain(domain string) (Domain, []DNSRecord, []DNSRecord, error) { r := simplehttp.NewHTTPRequest(generatePublicApiUrl(domainsEndpoint) + "/" + domain) r.SetBasicAuth(basicAuthUser, m.ApiKey()) var envelope singleDomainEnvelope err := getResponseFromJSON(r, &envelope) return envelope.Domain, envelope.ReceivingDNSRecords, envelope.SendingDNSRecords, err } // CreateDomain instructs Mailgun to create a new domain for your account. // The name parameter identifies the domain. // The smtpPassword parameter provides an access credential for the domain. // The spamAction domain must be one of Delete, Tag, or Disabled. // The wildcard parameter instructs Mailgun to treat all subdomains of this domain uniformly if true, // and as different domains if false. func (m *MailgunImpl) CreateDomain(name string, smtpPassword string, spamAction string, wildcard bool) error { r := simplehttp.NewHTTPRequest(generatePublicApiUrl(domainsEndpoint)) r.SetBasicAuth(basicAuthUser, m.ApiKey()) payload := simplehttp.NewUrlEncodedPayload() payload.AddValue("name", name) payload.AddValue("smtp_password", smtpPassword) payload.AddValue("spam_action", spamAction) payload.AddValue("wildcard", strconv.FormatBool(wildcard)) _, err := makePostRequest(r, payload) return err } // DeleteDomain instructs Mailgun to dispose of the named domain name. func (m *MailgunImpl) DeleteDomain(name string) error { r := simplehttp.NewHTTPRequest(generatePublicApiUrl(domainsEndpoint) + "/" + name) r.SetBasicAuth(basicAuthUser, m.ApiKey()) _, err := makeDeleteRequest(r) return err }