Merge pull request #45 from customerio/txnl-push

Transactional push support.

README.md

@@ -258,11 +258,11 @@ In order to send push notifications, we need customer device information.
 // platform (required)   - the platform of the device, currently only accepts 'ios' and 'android'
 // data (optional)       - a ```map[string]interface{}``` of information about the device. 
 //                         You can pass any key/value pairs that would be useful in your triggers. 
-//                         We currently only save 'last_used'.
 //                         Your interface{} should be parseable as Json by 'encoding/json'.Marshal
 
 if err := track.AddDevice("5", "messaging token", "android", map[string]interface{}{
 "last_used": time.Now().Unix(),
+"attribute_name": "attribute_value",
 }); err != nil {
   // handle error
 }
@@ -288,6 +288,7 @@ if err := track.DeleteDevice("5", "messaging-token"); err != nil {
 
 To use the Customer.io [Transactional API](https://customer.io/docs/transactional-api), create an instance of the API client using an [App API key](https://customer.io/docs/managing-credentials#app-api-keys).
 
+## Email
 Create a `customerio.SendEmailRequest` instance, and then use `(c *customerio.APIClient).SendEmail` to send your message. [Learn more about transactional messages and optional `SendEmailRequest` properties](https://customer.io/docs/transactional-api).
 
 You can also send attachments with your message. Use `customerio.SendEmailRequest.Attach` to encode attachments.
@@ -335,6 +336,42 @@ if err != nil {
 fmt.Println(body)
 ```
 
+## Push
+Create a `customerio.SendPushRequest` instance, and then use `(c *customerio.APIClient).SendPush` to send your message. [Learn more about transactional messages and optional `SendPush` properties](https://customer.io/docs/transactional-api).
+
+```go
+client := customerio.NewAPIClient("<extapikey>", customerio.WithRegion(customerio.RegionUS));
+
+request := customerio.SendPushRequest{
+  TransactionalMessageID: "3",
+  MessageData: map[string]interface{}{
+    "name": "Person",
+    "items": map[string]interface{}{
+      "name": "shoes",
+      "price": "59.99",
+    },
+    "products": []interface{}{},
+  },
+  Identifiers: map[string]string{
+    "id": "example1",
+  },
+}
+
+// (optional) upsert a particular device for the profile the push is being sent to.
+device, err := customerio.NewDevice("device-id", "android", map[string]interface{}{"optional_attr": "value"})
+if err != nil {
+  // handle error, invalid device params.
+}
+request.Device = device
+
+body, err := client.SendPush(context.Background(), &request)
+if err != nil {
+  // handle error
+}
+
+fmt.Println(body)
+```
+
 ## Context Support
 There are additional API methods that support passing a context that satisfies the `context.Context` interface to allow better control over dispatched requests. For example with sending an event:
 ```go

customerio.go

@@ -141,60 +141,6 @@ func (c *CustomerIO) DeleteCtx(ctx context.Context, customerID string) error {
 		nil)
 }
 
-// Delete deletes a customer
-func (c *CustomerIO) Delete(customerID string) error {
-	return c.DeleteCtx(context.Background(), customerID)
-}
-
-// AddDeviceCtx adds a device for a customer
-func (c *CustomerIO) AddDeviceCtx(ctx context.Context, customerID string, deviceID string, platform string, data map[string]interface{}) error {
-	if customerID == "" {
-		return ParamError{Param: "customerID"}
-	}
-	if deviceID == "" {
-		return ParamError{Param: "deviceID"}
-	}
-	if platform == "" {
-		return ParamError{Param: "platform"}
-	}
-
-	body := map[string]map[string]interface{}{
-		"device": {
-			"id":       deviceID,
-			"platform": platform,
-		},
-	}
-	for k, v := range data {
-		body["device"][k] = v
-	}
-	return c.request(ctx, "PUT",
-		fmt.Sprintf("%s/api/v1/customers/%s/devices", c.URL, url.PathEscape(customerID)),
-		body)
-}
-
-// AddDevice adds a device for a customer
-func (c *CustomerIO) AddDevice(customerID string, deviceID string, platform string, data map[string]interface{}) error {
-	return c.AddDeviceCtx(context.Background(), customerID, deviceID, platform, data)
-}
-
-// DeleteDeviceCtx deletes a device for a customer
-func (c *CustomerIO) DeleteDeviceCtx(ctx context.Context, customerID string, deviceID string) error {
-	if customerID == "" {
-		return ParamError{Param: "customerID"}
-	}
-	if deviceID == "" {
-		return ParamError{Param: "deviceID"}
-	}
-	return c.request(ctx, "DELETE",
-		fmt.Sprintf("%s/api/v1/customers/%s/devices/%s", c.URL, url.PathEscape(customerID), url.PathEscape(deviceID)),
-		nil)
-}
-
-// DeleteDevice deletes a device for a customer
-func (c *CustomerIO) DeleteDevice(customerID string, deviceID string) error {
-	return c.DeleteDeviceCtx(context.Background(), customerID, deviceID)
-}
-
 func (c *CustomerIO) auth() string {
 	return base64.URLEncoding.EncodeToString([]byte(fmt.Sprintf("%v:%v", c.siteID, c.apiKey)))
 }

device.go

@@ -0,0 +1,109 @@
+package customerio
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+)
+
+type deviceV1 struct {
+	ID         string                 `json:"id"`
+	Platform   string                 `json:"platform"`
+	LastUsed   string                 `json:"last_used,omitempty"`
+	Attributes map[string]interface{} `json:"attributes"`
+}
+
+type deviceV2 struct {
+	ID         string                 `json:"token"`
+	Platform   string                 `json:"platform"`
+	LastUsed   string                 `json:"last_used,omitempty"`
+	Attributes map[string]interface{} `json:"attributes"`
+}
+
+func newDeviceV1(deviceID, platform string, data map[string]interface{}) (*deviceV1, error) {
+	if deviceID == "" {
+		return nil, ParamError{Param: "deviceID"}
+	}
+	if platform == "" {
+		return nil, ParamError{Param: "platform"}
+	}
+	d := &deviceV1{
+		ID:       deviceID,
+		Platform: platform,
+	}
+
+	if len(data) > 0 {
+		d.Attributes = make(map[string]interface{})
+	}
+
+	for k, v := range data {
+		if k == "last_used" {
+			d.LastUsed = fmt.Sprintf("%v", v)
+			continue
+		}
+		d.Attributes[k] = v
+	}
+
+	return d, nil
+}
+
+func NewDevice(deviceID, platform string, data map[string]interface{}) (*deviceV2, error) {
+	d, err := newDeviceV1(deviceID, platform, data)
+	if err != nil {
+		return nil, err
+	}
+	return &deviceV2{
+		ID:         d.ID,
+		Platform:   d.Platform,
+		Attributes: d.Attributes,
+		LastUsed:   d.LastUsed,
+	}, nil
+}
+
+// Delete deletes a customer
+func (c *CustomerIO) Delete(customerID string) error {
+	return c.DeleteCtx(context.Background(), customerID)
+}
+
+// AddDeviceCtx adds a device for a customer
+func (c *CustomerIO) AddDeviceCtx(ctx context.Context, customerID string, deviceID string, platform string, data map[string]interface{}) error {
+	if customerID == "" {
+		return ParamError{Param: "customerID"}
+	}
+
+	d, err := newDeviceV1(deviceID, platform, data)
+	if err != nil {
+		return err
+	}
+
+	body := map[string]interface{}{
+		"device": d,
+	}
+
+	return c.request(ctx, "PUT",
+		fmt.Sprintf("%s/api/v1/customers/%s/devices", c.URL, url.PathEscape(customerID)),
+		body)
+}
+
+// AddDevice adds a device for a customer
+func (c *CustomerIO) AddDevice(customerID string, deviceID string, platform string, data map[string]interface{}) error {
+	return c.AddDeviceCtx(context.Background(), customerID, deviceID, platform, data)
+}
+
+// DeleteDeviceCtx deletes a device for a customer
+func (c *CustomerIO) DeleteDeviceCtx(ctx context.Context, customerID string, deviceID string) error {
+	if customerID == "" {
+		return ParamError{Param: "customerID"}
+	}
+	if deviceID == "" {
+		return ParamError{Param: "deviceID"}
+	}
+	return c.request(ctx, "DELETE",
+		fmt.Sprintf("%s/api/v1/customers/%s/devices/%s", c.URL, url.PathEscape(customerID), url.PathEscape(deviceID)),
+		nil)
+}
+
+// DeleteDevice deletes a device for a customer
+func (c *CustomerIO) DeleteDevice(customerID string, deviceID string) error {
+	return c.DeleteDeviceCtx(context.Background(), customerID, deviceID)
+}

examples/transactional.go

@@ -14,7 +14,7 @@ func main() {
 
 	client := customerio.NewAPIClient("<your-key-here>", customerio.WithRegion(customerio.RegionUS))
 
-	req := customerio.SendEmailRequest{
+	emailReq := customerio.SendEmailRequest{
 		Identifiers: map[string]string{
 			"id": "customer_1",
 		},
@@ -34,14 +34,33 @@ func main() {
 	}
 	defer f.Close()
 
-	if err := req.Attach("sample.pdf", f); err != nil {
+	if err := emailReq.Attach("sample.pdf", f); err != nil {
 		panic(err)
 	}
 
-	resp, err := client.SendEmail(ctx, &req)
+	emailResp, err := client.SendEmail(ctx, &emailReq)
 	if err != nil {
 		panic(err)
 	}
 
-	fmt.Println(resp)
+	fmt.Println(emailResp)
+
+	// Create and configure your transactional messages in the Customer.io UI.
+	transactionalMessageID := "push_message_id"
+
+	pushReq := customerio.SendPushRequest{
+		TransactionalMessageID: transactionalMessageID,
+		Identifiers: map[string]string{
+			"id": "customer_1",
+		},
+		Title:   "hello, {{ trigger.name }}",
+		Message: "hello from the Customer.io {{ trigger.client }} client",
+	}
+
+	pushResp, err := client.SendPush(ctx, &pushReq)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(pushResp)
 }

send_email.go

@@ -4,10 +4,8 @@ import (
 	"bytes"
 	"context"
 	"encoding/base64"
-	"encoding/json"
 	"errors"
 	"io"
-	"net/http"
 )
 
 type SendEmailRequest struct {
@@ -64,33 +62,12 @@ type SendEmailResponse struct {
 
 // SendEmail sends a single transactional email using the Customer.io transactional API
 func (c *APIClient) SendEmail(ctx context.Context, req *SendEmailRequest) (*SendEmailResponse, error) {
-	body, statusCode, err := c.doRequest(ctx, "POST", "/v1/send/email", req)
+	resp, err := c.sendTransactional(ctx, TransactionalTypeEmail, req)
 	if err != nil {
 		return nil, err
 	}
 
-	if statusCode != http.StatusOK {
-		var meta struct {
-			Meta struct {
-				Err string `json:"error"`
-			} `json:"meta"`
-		}
-		if err := json.Unmarshal(body, &meta); err != nil {
-			return nil, &TransactionalError{
-				StatusCode: statusCode,
-				Err:        string(body),
-			}
-		}
-		return nil, &TransactionalError{
-			StatusCode: statusCode,
-			Err:        meta.Meta.Err,
-		}
-	}
-
-	var result SendEmailResponse
-	if err := json.Unmarshal(body, &result); err != nil {
-		return nil, err
-	}
-
-	return &result, nil
+	return &SendEmailResponse{
+		*resp,
+	}, nil
 }

send_email_test.go

@@ -3,7 +3,6 @@ package customerio_test
 import (
 	"context"
 	"encoding/json"
-	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
@@ -28,41 +27,29 @@ func TestSendEmail(t *testing.T) {
 		},
 	}
 
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		b, err := ioutil.ReadAll(req.Body)
-		if err != nil {
-			t.Error(err)
-		}
-		defer req.Body.Close()
-
+	var verify = func(request []byte) {
 		var body customerio.SendEmailRequest
-		if err := json.Unmarshal(b, &body); err != nil {
+		if err := json.Unmarshal(request, &body); err != nil {
 			t.Error(err)
 		}
 
 		if !reflect.DeepEqual(&body, emailRequest) {
-			t.Errorf("Request differed, want: %#v, got: %#v", emailRequest, body)
+			t.Errorf("Request differed, want: %#v, got: %#v", request, body)
 		}
+	}
 
-		w.Write([]byte(`{
-			"delivery_id": "ABCDEFG",
-			"queued_at": 1500111111
-		  }`))
-	}))
+	api, srv := transactionalServer(t, verify)
 	defer srv.Close()
 
-	api := customerio.NewAPIClient("myKey")
-	api.URL = srv.URL
-
 	resp, err := api.SendEmail(context.Background(), emailRequest)
 	if err != nil {
 		t.Error(err)
 	}
 
 	expect := &customerio.SendEmailResponse{
 		TransactionalResponse: customerio.TransactionalResponse{
-			DeliveryID: "ABCDEFG",
-			QueuedAt:   time.Unix(1500111111, 0),
+			DeliveryID: testDeliveryID,
+			QueuedAt:   time.Unix(int64(testQueuedAt), 0),
 		},
 	}