Send JSON data to API

Author: Dirk Hoekstra

client.go

@@ -10,14 +10,15 @@
 package messagebird
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"log"
 	"net/http"
 	"net/url"
 	"runtime"
-	"strings"
 )
 
 const (
@@ -49,41 +50,46 @@ func New(AccessKey string) *Client {
 	return &Client{AccessKey: AccessKey, HTTPClient: &http.Client{}}
 }
 
-func (c *Client) request(v interface{}, path string, params *url.Values) error {
+func (c *Client) request(v interface{}, path string, data interface{}) error {
 	uri, err := url.Parse(Endpoint + "/" + path)
 	if err != nil {
 		return err
 	}
 
-	var request *http.Request
-	if params != nil {
-		body := params.Encode()
-		if request, err = http.NewRequest("POST", uri.String(), strings.NewReader(body)); err != nil {
+	method := "GET"
+	var jsonEncoded []byte
+	if data != nil {
+		jsonEncoded, err = json.Marshal(data)
+		method = "POST"
+		if err != nil {
 			return err
 		}
+	}
 
-		if c.DebugLog != nil {
-			if unescapedBody, queryError := url.QueryUnescape(body); queryError == nil {
-				log.Printf("HTTP REQUEST: POST %s %s", uri.String(), unescapedBody)
-			} else {
-				log.Printf("HTTP REQUEST: POST %s %s", uri.String(), body)
-			}
-		}
+	request, err := http.NewRequest(method, uri.String(), bytes.NewBuffer(jsonEncoded))
+	if err != nil {
+		return err
+	}
 
-		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	} else {
-		if request, err = http.NewRequest("GET", uri.String(), nil); err != nil {
-			return err
-		}
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Authorization", "AccessKey "+c.AccessKey)
+	request.Header.Add("User-Agent", "MessageBird/ApiClient/"+ClientVersion+" Go/"+runtime.Version())
 
-		if c.DebugLog != nil {
-			log.Printf("HTTP REQUEST: GET %s", uri.String())
+	if c.DebugLog != nil {
+		if data != nil {
+			log.Printf("HTTP REQUEST: %s %s %s", method, uri.String(), jsonEncoded)
+		} else {
+			log.Printf("HTTP REQUEST: %s %s", method, uri.String())
 		}
 	}
 
-	request.Header.Add("Accept", "application/json")
-	request.Header.Add("Authorization", "AccessKey "+c.AccessKey)
-	request.Header.Add("User-Agent", "MessageBird/ApiClient/"+ClientVersion+" Go/"+runtime.Version())
+	// TODO remove this
+	if data != nil {
+		fmt.Printf("HTTP REQUEST: %s %s %s\n", method, uri.String(), jsonEncoded)
+	} else {
+		fmt.Printf("HTTP REQUEST: %s %s\n", method, uri.String())
+	}
 
 	response, err := c.HTTPClient.Do(request)
 	if err != nil {
@@ -101,6 +107,9 @@ func (c *Client) request(v interface{}, path string, params *url.Values) error {
 		log.Printf("HTTP RESPONSE: %s", string(responseBody))
 	}
 
+	// TODO remove this
+	fmt.Printf("HTTP RESPONSE: %s\n", string(responseBody))
+
 	// Status code 500 is a server error and means nothing can be done at this
 	// point.
 	if response.StatusCode == 500 {
@@ -152,14 +161,14 @@ func (c *Client) HLR(id string) (*HLR, error) {
 }
 
 // NewHLR retrieves the information of an existing HLR.
-func (c *Client) NewHLR(msisdn, reference string) (*HLR, error) {
-	params := &url.Values{
-		"msisdn":    {msisdn},
-		"reference": {reference},
+func (c *Client) NewHLR(msisdn string, reference string) (*HLR, error) {
+	requestData, err := requestDataForHLR(msisdn, reference)
+	if err != nil {
+		return nil, err
 	}
 
 	hlr := &HLR{}
-	if err := c.request(hlr, "hlr", params); err != nil {
+	if err := c.request(hlr, "hlr", requestData); err != nil {
 		if err == ErrResponse {
 			return hlr, err
 		}
@@ -186,17 +195,13 @@ func (c *Client) Message(id string) (*Message, error) {
 
 // NewMessage creates a new message for one or more recipients.
 func (c *Client) NewMessage(originator string, recipients []string, body string, msgParams *MessageParams) (*Message, error) {
-	params, err := paramsForMessage(msgParams)
+	requestData, err := requestDataForMessage(originator, recipients, body, msgParams)
 	if err != nil {
 		return nil, err
 	}
 
-	params.Set("originator", originator)
-	params.Set("body", body)
-	params.Set("recipients", strings.Join(recipients, ","))
-
 	message := &Message{}
-	if err := c.request(message, "messages", params); err != nil {
+	if err := c.request(message, "messages", requestData); err != nil {
 		if err == ErrResponse {
 			return message, err
 		}
@@ -223,12 +228,13 @@ func (c *Client) VoiceMessage(id string) (*VoiceMessage, error) {
 
 // NewVoiceMessage creates a new voice message for one or more recipients.
 func (c *Client) NewVoiceMessage(recipients []string, body string, params *VoiceMessageParams) (*VoiceMessage, error) {
-	urlParams := paramsForVoiceMessage(params)
-	urlParams.Set("body", body)
-	urlParams.Set("recipients", strings.Join(recipients, ","))
+	requestData, err := requestDataForVoiceMessage(recipients, body, params)
+	if err != nil {
+		return nil, err
+	}
 
 	message := &VoiceMessage{}
-	if err := c.request(message, "voicemessages", urlParams); err != nil {
+	if err := c.request(message, "voicemessages", requestData); err != nil {
 		if err == ErrResponse {
 			return message, err
 		}
@@ -241,11 +247,13 @@ func (c *Client) NewVoiceMessage(recipients []string, body string, params *Voice
 
 // NewVerify generates a new One-Time-Password for one recipient.
 func (c *Client) NewVerify(recipient string, params *VerifyParams) (*Verify, error) {
-	urlParams := paramsForVerify(params)
-	urlParams.Set("recipient", recipient)
+	requestData, err := requestDataForVerify(recipient, params)
+	if err != nil {
+		return nil, err
+	}
 
 	verify := &Verify{}
-	if err := c.request(verify, "verify", urlParams); err != nil {
+	if err := c.request(verify, "verify", requestData); err != nil {
 		if err == ErrResponse {
 			return verify, err
 		}
@@ -294,11 +302,11 @@ func (c *Client) Lookup(phoneNumber string, params *LookupParams) (*Lookup, erro
 
 // NewLookupHLR creates a new HLR lookup for the specified number.
 func (c *Client) NewLookupHLR(phoneNumber string, params *LookupParams) (*HLR, error) {
-	urlParams := paramsForLookup(params)
+	requestData := requestDataForLookup(params)
 	path := "lookup/" + phoneNumber + "/hlr"
 
 	hlr := &HLR{}
-	if err := c.request(hlr, path, urlParams); err != nil {
+	if err := c.request(hlr, path, requestData); err != nil {
 		if err == ErrResponse {
 			return hlr, err
 		}

hlr.go

@@ -1,6 +1,9 @@
 package messagebird
 
-import "time"
+import (
+	"errors"
+	"time"
+)
 
 // HLR stands for Home Location Register.
 // Contains information about the subscribers identity, telephone number, the associated services and general information about the location of the subscriber
@@ -16,3 +19,24 @@ type HLR struct {
 	StatusDatetime  *time.Time
 	Errors          []Error
 }
+
+type hlrRequest struct {
+	MSISDN    string `json:"msisdn"`
+	Reference string `json:"reference"`
+}
+
+func requestDataForHLR(msisdn string, reference string) (*hlrRequest, error) {
+	request := &hlrRequest{}
+
+	if msisdn == "" {
+		return nil, errors.New("msisdn is required")
+	}
+	if reference == "" {
+		return nil, errors.New("reference is required")
+	}
+
+	request.MSISDN = msisdn
+	request.Reference = reference
+
+	return request, nil
+}

lookup.go

@@ -1,6 +1,8 @@
 package messagebird
 
-import "net/url"
+import (
+	"net/url"
+)
 
 // Formats represents phone number in multiple formats.
 type Formats struct {
@@ -27,6 +29,24 @@ type LookupParams struct {
 	Reference   string
 }
 
+type lookupRequest struct {
+	CountryCode string `json:"countryCode,omitempty"`
+	Reference   string `json:"reference,omitempty"`
+}
+
+func requestDataForLookup(params *LookupParams) *lookupRequest {
+	request := &lookupRequest{}
+
+	if params == nil {
+		return request
+	}
+
+	request.CountryCode = params.CountryCode
+	request.Reference = params.Reference
+
+	return request
+}
+
 func paramsForLookup(params *LookupParams) *url.Values {
 	urlParams := &url.Values{}
 

message.go

@@ -2,8 +2,6 @@ package messagebird
 
 import (
 	"errors"
-	"net/url"
-	"strconv"
 	"time"
 )
 
@@ -42,47 +40,52 @@ type MessageParams struct {
 	ScheduledDatetime time.Time
 }
 
-// paramsForMessage converts the specified MessageParams struct to a
-// url.Values pointer and returns it.
-func paramsForMessage(params *MessageParams) (*url.Values, error) {
-	urlParams := &url.Values{}
+type messageRequest struct {
+	Originator        string      `json:"originator"`
+	Body              string      `json:"body"`
+	Recipients        []string    `json:"recipients"`
+	Type              string      `json:"type,omitempty"`
+	Reference         string      `json:"reference,omitempty"`
+	Validity          int         `json:"validity,omitempty"`
+	Gateway           int         `json:"gateway,omitempty"`
+	TypeDetails       TypeDetails `json:"typeDetails,omitempty"`
+	DataCoding        string      `json:"dataCoding,omitempty"`
+	MClass            int         `json:"mclass,omitempty"`
+	ScheduledDatetime string      `json:"scheduledDatetime,omitempty"`
+}
 
-	if params == nil {
-		return urlParams, nil
-	}
+func requestDataForMessage(originator string, recipients []string, body string, params *MessageParams) (*messageRequest, error) {
+	request := &messageRequest{}
 
-	if params.Type != "" {
-		urlParams.Set("type", params.Type)
-		if params.Type == "flash" {
-			urlParams.Set("mclass", "0")
-		}
+	if originator == "" {
+		return nil, errors.New("originator is required")
 	}
-	if params.Reference != "" {
-		urlParams.Set("reference", params.Reference)
+	if len(recipients) == 0 {
+		return nil, errors.New("at least 1 recipient is required")
 	}
-	if params.Validity != 0 {
-		urlParams.Set("validity", strconv.Itoa(params.Validity))
-	}
-	if params.Gateway != 0 {
-		urlParams.Set("gateway", strconv.Itoa(params.Gateway))
+	if body == "" {
+		return nil, errors.New("body is required")
 	}
+	request.Originator = originator
+	request.Recipients = recipients
+	request.Body = body
 
-	for k, v := range params.TypeDetails {
-		if vs, ok := v.(string); ok {
-			urlParams.Set("typeDetails["+k+"]", vs)
-		} else if vi, ok := v.(int); ok {
-			urlParams.Set("typeDetails["+k+"]", strconv.Itoa(vi))
-		} else {
-			return nil, errors.New("Unknown type for typeDetails value")
-		}
+	if params == nil {
+		return request, nil
 	}
 
-	if params.DataCoding != "" {
-		urlParams.Set("datacoding", params.DataCoding)
-	}
-	if params.ScheduledDatetime.Unix() > 0 {
-		urlParams.Set("scheduledDatetime", params.ScheduledDatetime.Format(time.RFC3339))
+	request.Type = params.Type
+	if request.Type == "flash" {
+		request.MClass = 0
+	} else {
+		request.MClass = 1
 	}
+	request.Reference = params.Reference
+	request.Validity = params.Validity
+	request.Gateway = params.Gateway
+	request.TypeDetails = params.TypeDetails
+	request.DataCoding = params.DataCoding
+	request.ScheduledDatetime = params.ScheduledDatetime.Format(time.RFC3339)
 
-	return urlParams, nil
+	return request, nil
 }