add activity notifications methods

github/activity_notifications.go

@@ -0,0 +1,224 @@
+// Copyright 2014 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"fmt"
+	"time"
+)
+
+// Notification identifies a GitHub notification for a user.
+type Notification struct {
+	ID         *string              `json:"id,omitempty"`
+	Repository *Repository          `json:"repository,omitempty"`
+	Subject    *NotificationSubject `json:"subject,omitempty"`
+
+	// Reason identifies the event that triggered the notification.
+	//
+	// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#notification-reasons
+	Reason *string `json:"reason,omitempty"`
+
+	Unread     *bool      `json:"unread,omitempty"`
+	UpdatedAt  *time.Time `json:"updated_at,omitempty"`
+	LastReadAt *time.Time `json:"last_read_at,omitempty"`
+	URL        *string    `json:"url,omitempty"`
+}
+
+// NotificationSubject identifies the subject of a notification.
+type NotificationSubject struct {
+	Title            *string `json:"title,omitempty"`
+	URL              *string `json:"url,omitempty"`
+	LatestCommentURL *string `json:"latest_comment_url,omitempty"`
+	Type             *string `json:"type,omitempty"`
+}
+
+// NotificationListOptions specifies the optional parameters to the
+// ActivityService.ListNotifications method.
+type NotificationListOptions struct {
+	All           bool      `url:"all,omitempty"`
+	Participating bool      `url:"participating,omitempty"`
+	Since         time.Time `url:"since,omitempty"`
+}
+
+// ListNotifications lists all notifications for the authenticated user.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#list-your-notifications
+func (s *ActivityService) ListNotifications(opt *NotificationListOptions) ([]Notification, *Response, error) {
+	u := fmt.Sprintf("notifications")
+	u, err := addOptions(u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var notifications []Notification
+	resp, err := s.client.Do(req, &notifications)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return notifications, resp, err
+}
+
+// ListRepositoryNotifications lists all notifications in a given repository
+// for the authenticated user.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#list-your-notifications-in-a-repository
+func (s *ActivityService) ListRepositoryNotifications(owner, repo string, opt *NotificationListOptions) ([]Notification, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/notifications", owner, repo)
+	u, err := addOptions(u, opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var notifications []Notification
+	resp, err := s.client.Do(req, &notifications)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return notifications, resp, err
+}
+
+type markReadOptions struct {
+	LastReadAt time.Time `url:"last_read_at,omitempty"`
+}
+
+// MarkNotificationsRead marks all notifications up to lastRead as read.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#mark-as-read
+func (s *ActivityService) MarkNotificationsRead(lastRead time.Time) (*Response, error) {
+	u := fmt.Sprintf("notifications")
+	u, err := addOptions(u, markReadOptions{lastRead})
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(req, nil)
+}
+
+// MarkRepositoryNotificationsRead marks all notifications up to lastRead in
+// the specified repository as read.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#mark-notifications-as-read-in-a-repository
+func (s *ActivityService) MarkRepositoryNotificationsRead(owner, repo string, lastRead time.Time) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/notifications", owner, repo)
+	u, err := addOptions(u, markReadOptions{lastRead})
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(req, nil)
+}
+
+// GetThread gets the specified notification thread.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#view-a-single-thread
+func (s *ActivityService) GetThread(id string) (*Notification, *Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v", id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	notification := new(Notification)
+	resp, err := s.client.Do(req, notification)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return notification, resp, err
+}
+
+// MarkThreadRead marks the specified thread as read.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#mark-a-thread-as-read
+func (s *ActivityService) MarkThreadRead(id string) (*Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v", id)
+
+	req, err := s.client.NewRequest("PATCH", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(req, nil)
+}
+
+// GetThreadSubscription checks to see if the authenticated user is subscribed
+// to a thread.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#get-a-thread-subscription
+func (s *ActivityService) GetThreadSubscription(id string) (*Subscription, *Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sub := new(Subscription)
+	resp, err := s.client.Do(req, sub)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sub, resp, err
+}
+
+// SetThreadSubscription sets the subscription for the specified thread for the
+// authenticated user.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#set-a-thread-subscription
+func (s *ActivityService) SetThreadSubscription(id string, subscription *Subscription) (*Subscription, *Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
+
+	req, err := s.client.NewRequest("PUT", u, subscription)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sub := new(Subscription)
+	resp, err := s.client.Do(req, sub)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sub, resp, err
+}
+
+// DeleteThreadSubscription deletes the subscription for the specified thread
+// for the authenticated user.
+//
+// GitHub API Docs: https://developer.github.com/v3/activity/notifications/#delete-a-thread-subscription
+func (s *ActivityService) DeleteThreadSubscription(id string) (*Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(req, nil)
+}

github/activity_notifications_test.go

@@ -0,0 +1,203 @@
+// Copyright 2014 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestActivityService_ListNotification(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/notifications", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		testFormValues(t, r, values{
+			"all":           "true",
+			"participating": "true",
+			"since":         "2006-01-02T15:04:05Z",
+		})
+
+		fmt.Fprint(w, `[{"id":"1", "subject":{"title":"t"}}]`)
+	})
+
+	opt := &NotificationListOptions{
+		All:           true,
+		Participating: true,
+		Since:         time.Date(2006, 01, 02, 15, 04, 05, 0, time.UTC),
+	}
+	notifications, _, err := client.Activity.ListNotifications(opt)
+	if err != nil {
+		t.Errorf("Activity.ListNotifications returned error: %v", err)
+	}
+
+	want := []Notification{{ID: String("1"), Subject: &NotificationSubject{Title: String("t")}}}
+	if !reflect.DeepEqual(notifications, want) {
+		t.Errorf("Activity.ListNotifications returned %+v, want %+v", notifications, want)
+	}
+}
+
+func TestActivityService_ListRepositoryNotification(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/repos/o/r/notifications", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `[{"id":"1"}]`)
+	})
+
+	notifications, _, err := client.Activity.ListRepositoryNotifications("o", "r", nil)
+	if err != nil {
+		t.Errorf("Activity.ListRepositoryNotifications returned error: %v", err)
+	}
+
+	want := []Notification{{ID: String("1")}}
+	if !reflect.DeepEqual(notifications, want) {
+		t.Errorf("Activity.ListRepositoryNotifications returned %+v, want %+v", notifications, want)
+	}
+}
+
+func TestActivityService_MarkNotificationsRead(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/notifications", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PUT")
+		testFormValues(t, r, values{
+			"last_read_at": "2006-01-02T15:04:05Z",
+		})
+
+		w.WriteHeader(http.StatusResetContent)
+	})
+
+	_, err := client.Activity.MarkNotificationsRead(time.Date(2006, 01, 02, 15, 04, 05, 0, time.UTC))
+	if err != nil {
+		t.Errorf("Activity.MarkNotificationsRead returned error: %v", err)
+	}
+}
+
+func TestActivityService_MarkRepositoryNotificationsRead(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/repos/o/r/notifications", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PUT")
+		testFormValues(t, r, values{
+			"last_read_at": "2006-01-02T15:04:05Z",
+		})
+
+		w.WriteHeader(http.StatusResetContent)
+	})
+
+	_, err := client.Activity.MarkRepositoryNotificationsRead("o", "r", time.Date(2006, 01, 02, 15, 04, 05, 0, time.UTC))
+	if err != nil {
+		t.Errorf("Activity.MarkRepositoryNotificationsRead returned error: %v", err)
+	}
+}
+
+func TestActivityService_GetThread(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/notifications/threads/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{"id":"1"}`)
+	})
+
+	notification, _, err := client.Activity.GetThread("1")
+	if err != nil {
+		t.Errorf("Activity.GetThread returned error: %v", err)
+	}
+
+	want := &Notification{ID: String("1")}
+	if !reflect.DeepEqual(notification, want) {
+		t.Errorf("Activity.GetThread returned %+v, want %+v", notification, want)
+	}
+}
+
+func TestActivityService_MarkThreadRead(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/notifications/threads/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PATCH")
+		w.WriteHeader(http.StatusResetContent)
+	})
+
+	_, err := client.Activity.MarkThreadRead("1")
+	if err != nil {
+		t.Errorf("Activity.MarkThreadRead returned error: %v", err)
+	}
+}
+
+func TestActivityService_GetThreadSubscription(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/notifications/threads/1/subscription", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{"subscribed":true}`)
+	})
+
+	sub, _, err := client.Activity.GetThreadSubscription("1")
+	if err != nil {
+		t.Errorf("Activity.GetThreadSubscription returned error: %v", err)
+	}
+
+	want := &Subscription{Subscribed: Bool(true)}
+	if !reflect.DeepEqual(sub, want) {
+		t.Errorf("Activity.GetThreadSubscription returned %+v, want %+v", sub, want)
+	}
+}
+
+func TestActivityService_SetThreadSubscription(t *testing.T) {
+	setup()
+	defer teardown()
+
+	input := &Subscription{Subscribed: Bool(true)}
+
+	mux.HandleFunc("/notifications/threads/1/subscription", func(w http.ResponseWriter, r *http.Request) {
+		v := new(Subscription)
+		json.NewDecoder(r.Body).Decode(v)
+
+		testMethod(t, r, "PUT")
+		if !reflect.DeepEqual(v, input) {
+			t.Errorf("Request body = %+v, want %+v", v, input)
+		}
+
+		fmt.Fprint(w, `{"ignored":true}`)
+	})
+
+	sub, _, err := client.Activity.SetThreadSubscription("1", input)
+	if err != nil {
+		t.Errorf("Activity.SetThreadSubscription returned error: %v", err)
+	}
+
+	want := &Subscription{Ignored: Bool(true)}
+	if !reflect.DeepEqual(sub, want) {
+		t.Errorf("Activity.SetThreadSubscription returned %+v, want %+v", sub, want)
+	}
+}
+
+func TestActivityService_DeleteThreadSubscription(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/notifications/threads/1/subscription", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "DELETE")
+		w.WriteHeader(http.StatusNoContent)
+	})
+
+	_, err := client.Activity.DeleteThreadSubscription("1")
+	if err != nil {
+		t.Errorf("Activity.DeleteThreadSubscription returned error: %v", err)
+	}
+}