132 lines
3.3 KiB
Go
132 lines
3.3 KiB
Go
package mailgun
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
)
|
|
|
|
type DomainResponse struct {
|
|
Domain Domain `json:"domain"`
|
|
SendingRecords []SendingRecord `json:"sending_dns_records"`
|
|
ReceivingRecords []ReceivingRecord `json:"receiving_dns_records"`
|
|
}
|
|
|
|
// Domain is used to represent a retrieved Domain. All properties
|
|
// are set as strings.
|
|
type Domain struct {
|
|
Name string `json:"name"`
|
|
SmtpLogin string `json:"smtp_login"`
|
|
SmtpPassword string `json:"smtp_password"`
|
|
SpamAction string `json:"spam_action"`
|
|
Wildcard bool `json:"wildcard"`
|
|
}
|
|
|
|
type SendingRecord struct {
|
|
Name string `json:"name"`
|
|
RecordType string `json:"record_type"`
|
|
Valid string `json:"valid"`
|
|
Value string `json:"value"`
|
|
}
|
|
|
|
type ReceivingRecord struct {
|
|
Priority string `json:"priority"`
|
|
RecordType string `json:"record_type"`
|
|
Valid string `json:"valid"`
|
|
Value string `json:"value"`
|
|
}
|
|
|
|
func (d *Domain) StringWildcard() string {
|
|
return strconv.FormatBool(d.Wildcard)
|
|
}
|
|
|
|
// CreateDomain contains the request parameters to create a new
|
|
// domain.
|
|
type CreateDomain struct {
|
|
Name string // Name of the domain
|
|
SmtpPassword string
|
|
SpamAction string // one of disabled or tag
|
|
Wildcard bool
|
|
}
|
|
|
|
// CreateDomain creates a domain from the parameters specified and
|
|
// returns an error if it fails. If no error and the name is returned,
|
|
// the Domain was succesfully created.
|
|
func (c *Client) CreateDomain(opts *CreateDomain) (string, error) {
|
|
// Make the request parameters
|
|
params := make(map[string]string)
|
|
|
|
params["name"] = opts.Name
|
|
params["smtp_password"] = opts.SmtpPassword
|
|
params["spam_action"] = opts.SpamAction
|
|
params["wildcard"] = strconv.FormatBool(opts.Wildcard)
|
|
|
|
req, err := c.NewRequest(params, "POST", "/domains")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
resp, err := checkResp(c.Http.Do(req))
|
|
|
|
if err != nil {
|
|
return "", fmt.Errorf("Error creating domain: %s", err)
|
|
}
|
|
|
|
domain := new(DomainResponse)
|
|
|
|
err = decodeBody(resp, &domain)
|
|
|
|
if err != nil {
|
|
return "", fmt.Errorf("Error parsing domain response: %s", err)
|
|
}
|
|
|
|
// The request was successful
|
|
return domain.Domain.Name, nil
|
|
}
|
|
|
|
// DestroyDomain destroys a domain by the ID specified and
|
|
// returns an error if it fails. If no error is returned,
|
|
// the Domain was succesfully destroyed.
|
|
func (c *Client) DestroyDomain(name string) error {
|
|
req, err := c.NewRequest(map[string]string{}, "DELETE", fmt.Sprintf("/domains/%s", name))
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = checkResp(c.Http.Do(req))
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("Error destroying domain: %s", err)
|
|
}
|
|
|
|
// The request was successful
|
|
return nil
|
|
}
|
|
|
|
// RetrieveDomain gets a domain and records by the ID specified and
|
|
// returns a DomainResponse and an error. An error will be returned for failed
|
|
// requests with a nil DomainResponse.
|
|
func (c *Client) RetrieveDomain(name string) (DomainResponse, error) {
|
|
req, err := c.NewRequest(map[string]string{}, "GET", fmt.Sprintf("/domains/%s", name))
|
|
|
|
if err != nil {
|
|
return DomainResponse{}, err
|
|
}
|
|
|
|
resp, err := checkResp(c.Http.Do(req))
|
|
if err != nil {
|
|
return DomainResponse{}, fmt.Errorf("Error destroying domain: %s", err)
|
|
}
|
|
|
|
domainresp := new(DomainResponse)
|
|
|
|
err = decodeBody(resp, domainresp)
|
|
|
|
if err != nil {
|
|
return DomainResponse{}, fmt.Errorf("Error decoding domain response: %s", err)
|
|
}
|
|
|
|
// The request was successful
|
|
return *domainresp, nil
|
|
}
|