pushnotification/pushnotification.go at master · Iwark/pushnotification · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package pushnotification

import (
	"encoding/json"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/credentials"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/sns"
)

// Service is the main entry point into using this package.
type Service struct {
	AWSAccessKey         string
	AWSAccessSecret      string
	AWSSNSApplicationARN string
	AWSRegion            string
}

// Data is the data of the sending pushnotification.
type Data struct {
	Alert *string     `json:"alert,omitempty"`
	Sound *string     `json:"sound,omitempty"`
	Data  interface{} `json:"custom_data"`
	Badge *int        `json:"badge,omitempty"`
}

// Send sends a push notification
func (s *Service) Send(deviceToken string, data *Data) (err error) {

	svc := sns.New(session.New(&aws.Config{
		Credentials: credentials.NewStaticCredentials(s.AWSAccessKey, s.AWSAccessSecret, ""),
		Region:      aws.String(s.AWSRegion),
	}))

	resp, err := svc.CreatePlatformEndpoint(&sns.CreatePlatformEndpointInput{
		PlatformApplicationArn: aws.String(s.AWSSNSApplicationARN),
		Token: aws.String(deviceToken),
	})
	if err != nil {
		return
	}

	m, err := newMessageJSON(data)
	if err != nil {
		return
	}

	input := &sns.PublishInput{
		Message:          aws.String(m),
		MessageStructure: aws.String("json"),
		TargetArn:        aws.String(*resp.EndpointArn),
	}
	_, err = svc.Publish(input)
	return
}

type message struct {
	APNS        string `json:"APNS"`
	APNSSandbox string `json:"APNS_SANDBOX"`
	Default     string `json:"default"`
	GCM         string `json:"GCM"`
}

type iosPush struct {
	APS Data `json:"aps"`
}

type gcmPush struct {
	Message *string     `json:"message,omitempty"`
	Custom  interface{} `json:"custom"`
	Badge   *int        `json:"badge,omitempty"`
}

type gcmPushWrapper struct {
	Data gcmPush `json:"data"`
}

func newMessageJSON(data *Data) (m string, err error) {
	b, err := json.Marshal(iosPush{
		APS: *data,
	})
	if err != nil {
		return
	}
	payload := string(b)

	b, err = json.Marshal(gcmPushWrapper{
		Data: gcmPush{
			Message: data.Alert,
			Custom:  data.Data,
			Badge:   data.Badge,
		},
	})
	if err != nil {
		return
	}
	gcm := string(b)

	pushData, err := json.Marshal(message{
		Default:     *data.Alert,
		APNS:        payload,
		APNSSandbox: payload,
		GCM:         gcm,
	})
	if err != nil {
		return
	}
	m = string(pushData)
	return
}