Merge pull request #18 from messagebird/json-requests

Switch from url encoded data to JSON data

Author: cooldarkdryplace

client.go

@@ -10,6 +10,7 @@
 package messagebird
 
 import (
+	"bytes"
 	"encoding/json"
 	"errors"
 	"io/ioutil"
@@ -64,42 +65,40 @@ 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)
+		if err != nil {
 			return err
 		}
+		method = "POST"
+	}
 
-		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.Set("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())
-
 	response, err := c.HTTPClient.Do(request)
 	if err != nil {
 		return err
@@ -182,14 +181,15 @@ func (c *Client) HLRs() (*HLRList, 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, HLRPath, params); err != nil {
+
+	if err := c.request(hlr, HLRPath, requestData); err != nil {
 		if err == ErrResponse {
 			return hlr, err
 		}
@@ -235,17 +235,13 @@ func (c *Client) Messages(msgListParams *MessageListParams) (*MessageList, 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, MessagePath, params); err != nil {
+	if err := c.request(message, MessagePath, requestData); err != nil {
 		if err == ErrResponse {
 			return message, err
 		}
@@ -322,12 +318,13 @@ func (c *Client) VoiceMessages() (*VoiceMessageList, 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, VoiceMessagePath, urlParams); err != nil {
+	if err := c.request(message, VoiceMessagePath, requestData); err != nil {
 		if err == ErrResponse {
 			return message, err
 		}
@@ -340,11 +337,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, VerifyPath, urlParams); err != nil {
+	if err := c.request(verify, VerifyPath, requestData); err != nil {
 		if err == ErrResponse {
 			return verify, err
 		}
@@ -393,11 +392,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 := LookupPath + "/" + phoneNumber + "/" + HLRPath
 
 	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
@@ -26,3 +29,24 @@ type HLRList struct {
 	Links      map[string]*string
 	Items      []HLR
 }
+
+type hlrRequest struct {
+	MSISDN    string `json:"msisdn"`
+	Reference string `json:"reference"`
+}
+
+func requestDataForHLR(msisdn string, reference string) (*hlrRequest, error) {
+	if msisdn == "" {
+		return nil, errors.New("msisdn is required")
+	}
+	if reference == "" {
+		return nil, errors.New("reference is required")
+	}
+
+	request := &hlrRequest{
+		MSISDN:    msisdn,
+		Reference: reference,
+	}
+
+	return request, nil
+}

hlr_test.go

@@ -97,6 +97,20 @@ func TestHLR(t *testing.T) {
 	assertHLRObject(t, hlr)
 }
 
+func TestRequestDataForHLR(t *testing.T) {
+	requestData, err := requestDataForHLR("31612345678", "MyReference")
+	if err != nil {
+		t.Fatalf("Didn't expect an error while getting the request data for a HLR: %s", err)
+	}
+
+	if requestData.MSISDN != "31612345678" {
+		t.Errorf("Unexpected msisdn: %s, expected: 31612345678", requestData.MSISDN)
+	}
+	if requestData.Reference != "MyReference" {
+		t.Errorf("Unexpected reference: %s, expected: MyReference", requestData.Reference)
+	}
+}
+
 func TestNewHLR(t *testing.T) {
 	SetServerResponse(http.StatusOK, hlrObject)
 

lookup.go

@@ -27,6 +27,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{}
 

lookup_test.go

@@ -90,6 +90,21 @@ func TestLookupHLR(t *testing.T) {
 	checkHLR(t, hlr)
 }
 
+func TestRequestDataForLookupHLR(t *testing.T) {
+	lookupParams := &LookupParams{
+		CountryCode: "NL",
+		Reference:   "MyReference",
+	}
+	request := requestDataForLookup(lookupParams)
+
+	if request.CountryCode != "NL" {
+		t.Errorf("Unexpected country code: %s, expected: NL", request.CountryCode)
+	}
+	if request.Reference != "MyReference" {
+		t.Errorf("Unexpected reference: %s, expected: MyReference", request.Reference)
+	}
+}
+
 func TestNewLookupHLR(t *testing.T) {
 	SetServerResponse(201, lookupHLRObject)
 

message.go

@@ -61,49 +61,55 @@ type MessageListParams struct {
 	Offset     int
 }
 
-// paramsForMessage converts the specified MessageParams struct to a
-// url.Values pointer and returns it.
-func paramsForMessage(params *MessageParams) (*url.Values, error) {
-	urlParams := &url.Values{}
-
-	if params == nil {
-		return urlParams, nil
-	}
+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.Type != "" {
-		urlParams.Set("type", params.Type)
-		if params.Type == "flash" {
-			urlParams.Set("mclass", "0")
-		}
-	}
-	if params.Reference != "" {
-		urlParams.Set("reference", params.Reference)
+func requestDataForMessage(originator string, recipients []string, body string, params *MessageParams) (*messageRequest, error) {
+	if originator == "" {
+		return nil, errors.New("originator is required")
 	}
-	if params.Validity != 0 {
-		urlParams.Set("validity", strconv.Itoa(params.Validity))
+	if len(recipients) == 0 {
+		return nil, errors.New("at least 1 recipient is required")
 	}
-	if params.Gateway != 0 {
-		urlParams.Set("gateway", strconv.Itoa(params.Gateway))
+	if body == "" {
+		return nil, errors.New("body is required")
 	}
 
-	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")
-		}
+	request := &messageRequest{
+		Originator: originator,
+		Recipients: recipients,
+		Body:       body,
 	}
 
-	if params.DataCoding != "" {
-		urlParams.Set("datacoding", params.DataCoding)
-	}
-	if params.ScheduledDatetime.Unix() > 0 {
-		urlParams.Set("scheduledDatetime", params.ScheduledDatetime.Format(time.RFC3339))
+	if params == nil {
+		return request, nil
 	}
 
-	return urlParams, nil
+	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 request, nil
 }
 
 // paramsForMessageList converts the specified MessageListParams struct to a