Codebase list golang-github-nlopes-slack / 95a7abf
Merge pull request #60 from nlopes/nlopes-add-dnd Add dnd Norberto Lopes 8 years ago
4 changed file(s) with 293 addition(s) and 0 deletion(s). Raw diff Collapse all Expand all
+123
-0
dnd.go less more
0 package slack
1
2 import (
3 "errors"
4 "net/url"
5 "strconv"
6 "strings"
7 )
8
9 type SnoozeDebug struct {
10 SnoozeEndDate string `json:"snooze_end_date"`
11 }
12
13 type SnoozeInfo struct {
14 SnoozeEnabled bool `json:"snooze_enabled,omitempty"`
15 SnoozeEndTime int `json:"snooze_endtime,omitempty"`
16 SnoozeRemaining int `json:"snooze_remaining,omitempty"`
17 SnoozeDebug SnoozeDebug `json:"snooze_debug,omitempty"`
18 }
19
20 type DNDStatus struct {
21 Enabled bool `json:"dnd_enabled"`
22 NextStartTimestamp int `json:"next_dnd_start_ts"`
23 NextEndTimestamp int `json:"next_dnd_end_ts"`
24 SnoozeInfo
25 }
26
27 type dndResponseFull struct {
28 DNDStatus
29 SlackResponse
30 }
31
32 type dndTeamInfoResponse struct {
33 Users map[string]DNDStatus `json:"users"`
34 SlackResponse
35 }
36
37 func dndRequest(path string, values url.Values, debug bool) (*dndResponseFull, error) {
38 response := &dndResponseFull{}
39 err := post(path, values, response, debug)
40 if err != nil {
41 return nil, err
42 }
43 if !response.Ok {
44 return nil, errors.New(response.Error)
45 }
46 return response, nil
47 }
48
49 // EndDND ends the user's scheduled Do Not Disturb session
50 func (api *Client) EndDND() error {
51 values := url.Values{
52 "token": {api.config.token},
53 }
54
55 response := &SlackResponse{}
56 if err := post("dnd.endDnd", values, response, api.debug); err != nil {
57 return err
58 }
59 if !response.Ok {
60 return errors.New(response.Error)
61 }
62 return nil
63 }
64
65 // EndSnooze ends the current user's snooze mode
66 func (api *Client) EndSnooze() (*DNDStatus, error) {
67 values := url.Values{
68 "token": {api.config.token},
69 }
70
71 response, err := dndRequest("dnd.endSnooze", values, api.debug)
72 if err != nil {
73 return nil, err
74 }
75 return &response.DNDStatus, nil
76 }
77
78 // GetDNDInfo provides information about a user's current Do Not Disturb settings.
79 func (api *Client) GetDNDInfo(user *string) (*DNDStatus, error) {
80 values := url.Values{
81 "token": {api.config.token},
82 }
83 if user != nil {
84 values.Set("user", *user)
85 }
86 response, err := dndRequest("dnd.info", values, api.debug)
87 if err != nil {
88 return nil, err
89 }
90 return &response.DNDStatus, nil
91 }
92
93 // GetDNDTeamInfo provides information about a user's current Do Not Disturb settings.
94 func (api *Client) GetDNDTeamInfo(users []string) (map[string]DNDStatus, error) {
95 values := url.Values{
96 "token": {api.config.token},
97 "users": {strings.Join(users, ",")},
98 }
99 response := &dndTeamInfoResponse{}
100 if err := post("dnd.teamInfo", values, response, api.debug); err != nil {
101 return nil, err
102 }
103 if !response.Ok {
104 return nil, errors.New(response.Error)
105 }
106 return response.Users, nil
107 }
108
109 // SetSnooze adjusts the snooze duration for a user's Do Not Disturb
110 // settings. If a snooze session is not already active for the user, invoking
111 // this method will begin one for the specified duration.
112 func (api *Client) SetSnooze(minutes int) (*DNDStatus, error) {
113 values := url.Values{
114 "token": {api.config.token},
115 "num_minutes": {strconv.Itoa(minutes)},
116 }
117 response, err := dndRequest("dnd.setSnooze", values, api.debug)
118 if err != nil {
119 return nil, err
120 }
121 return &response.DNDStatus, nil
122 }
+159
-0
dnd_test.go less more
0 package slack
1
2 import (
3 "net/http"
4 "reflect"
5 "testing"
6 )
7
8 func TestSlack_EndDND(t *testing.T) {
9 http.HandleFunc("/dnd.endDnd", func(w http.ResponseWriter, r *http.Request) {
10 w.Header().Set("Content-Type", "application/json")
11 w.Write([]byte(`{ "ok": true }`))
12 })
13 once.Do(startServer)
14 SLACK_API = "http://" + serverAddr + "/"
15 api := New("testing-token")
16 err := api.EndDND()
17 if err != nil {
18 t.Fatalf("Unexpected error: %s", err)
19 }
20 }
21
22 func TestSlack_EndSnooze(t *testing.T) {
23 http.HandleFunc("/dnd.endSnooze", func(w http.ResponseWriter, r *http.Request) {
24 w.Header().Set("Content-Type", "application/json")
25 w.Write([]byte(`{ "ok": true,
26 "dnd_enabled": true,
27 "next_dnd_start_ts": 1450418400,
28 "next_dnd_end_ts": 1450454400,
29 "snooze_enabled": false }`))
30 })
31 state := DNDStatus{
32 Enabled: true,
33 NextStartTimestamp: 1450418400,
34 NextEndTimestamp: 1450454400,
35 SnoozeInfo: SnoozeInfo{SnoozeEnabled: false},
36 }
37 once.Do(startServer)
38 SLACK_API = "http://" + serverAddr + "/"
39 api := New("testing-token")
40 snoozeState, err := api.EndSnooze()
41 if err != nil {
42 t.Fatalf("Unexpected error: %s", err)
43 }
44 eq := reflect.DeepEqual(snoozeState, &state)
45 if !eq {
46 t.Errorf("got %v; want %v", snoozeState, &state)
47 }
48 }
49
50 func TestSlack_GetDNDInfo(t *testing.T) {
51 http.HandleFunc("/dnd.info", func(w http.ResponseWriter, r *http.Request) {
52 w.Header().Set("Content-Type", "application/json")
53 w.Write([]byte(`{
54 "ok": true,
55 "dnd_enabled": true,
56 "next_dnd_start_ts": 1450416600,
57 "next_dnd_end_ts": 1450452600,
58 "snooze_enabled": true,
59 "snooze_endtime": 1450416600,
60 "snooze_remaining": 1196
61 }`))
62 })
63 userDNDInfo := DNDStatus{
64 Enabled: true,
65 NextStartTimestamp: 1450416600,
66 NextEndTimestamp: 1450452600,
67 SnoozeInfo: SnoozeInfo{
68 SnoozeEnabled: true,
69 SnoozeEndTime: 1450416600,
70 SnoozeRemaining: 1196,
71 },
72 }
73 once.Do(startServer)
74 SLACK_API = "http://" + serverAddr + "/"
75 api := New("testing-token")
76 userDNDInfoResponse, err := api.GetDNDInfo(nil)
77 if err != nil {
78 t.Fatalf("Unexpected error: %s", err)
79 }
80 eq := reflect.DeepEqual(userDNDInfoResponse, &userDNDInfo)
81 if !eq {
82 t.Errorf("got %v; want %v", userDNDInfoResponse, &userDNDInfo)
83 }
84 }
85
86 func TestSlack_GetDNDTeamInfo(t *testing.T) {
87 http.HandleFunc("/dnd.teamInfo", func(w http.ResponseWriter, r *http.Request) {
88 w.Header().Set("Content-Type", "application/json")
89 w.Write([]byte(`{
90 "ok": true,
91 "users": {
92 "U023BECGF": {
93 "dnd_enabled": true,
94 "next_dnd_start_ts": 1450387800,
95 "next_dnd_end_ts": 1450423800
96 },
97 "U058CJVAA": {
98 "dnd_enabled": false,
99 "next_dnd_start_ts": 1,
100 "next_dnd_end_ts": 1
101 }
102 }
103 }`))
104 })
105 usersDNDInfo := map[string]DNDStatus{
106 "U023BECGF": DNDStatus{
107 Enabled: true,
108 NextStartTimestamp: 1450387800,
109 NextEndTimestamp: 1450423800,
110 },
111 "U058CJVAA": DNDStatus{
112 Enabled: false,
113 NextStartTimestamp: 1,
114 NextEndTimestamp: 1,
115 },
116 }
117 once.Do(startServer)
118 SLACK_API = "http://" + serverAddr + "/"
119 api := New("testing-token")
120 usersDNDInfoResponse, err := api.GetDNDTeamInfo(nil)
121 if err != nil {
122 t.Fatalf("Unexpected error: %s", err)
123 }
124 eq := reflect.DeepEqual(usersDNDInfoResponse, usersDNDInfo)
125 if !eq {
126 t.Errorf("got %v; want %v", usersDNDInfoResponse, usersDNDInfo)
127 }
128 }
129
130 func TestSlack_SetSnooze(t *testing.T) {
131 http.HandleFunc("/dnd.setSnooze", func(w http.ResponseWriter, r *http.Request) {
132 w.Header().Set("Content-Type", "application/json")
133 w.Write([]byte(`{
134 "ok": true,
135 "dnd_enabled": true,
136 "snooze_endtime": 1450373897,
137 "snooze_remaining": 60
138 }`))
139 })
140 snooze := DNDStatus{
141 Enabled: true,
142 SnoozeInfo: SnoozeInfo{
143 SnoozeEndTime: 1450373897,
144 SnoozeRemaining: 60,
145 },
146 }
147 once.Do(startServer)
148 SLACK_API = "http://" + serverAddr + "/"
149 api := New("testing-token")
150 snoozeResponse, err := api.SetSnooze(60)
151 if err != nil {
152 t.Fatalf("Unexpected error: %s", err)
153 }
154 eq := reflect.DeepEqual(snoozeResponse, &snooze)
155 if !eq {
156 t.Errorf("got %v; want %v", snoozeResponse, &snooze)
157 }
158 }
+8
-0
websocket_dnd.go less more
0 package slack
1
2 // DNDUpdatedEvent represents the update event for Do Not Disturb
3 type DNDUpdatedEvent struct {
4 Type string `json:"type"`
5 User string `json:"user"`
6 Status DNDStatus `json:"dnd_status"`
7 }
+3
-0
websocket_managed_conn.go less more
360360 "channel_unarchive": ChannelUnarchiveEvent{},
361361 "channel_history_changed": ChannelHistoryChangedEvent{},
362362
363 "dnd_updated": DNDUpdatedEvent{},
364 "dnd_updated_user": DNDUpdatedEvent{},
365
363366 "im_created": IMCreatedEvent{},
364367 "im_open": IMOpenEvent{},
365368 "im_close": IMCloseEvent{},