checkpoint: notifications implementation

cmd/enbas/main.go

@@ -15,21 +15,23 @@ const (
 	listTitleFlag         = "list-title"
 	listRepliesPolicyFlag = "list-replies-policy"
 	myAccountFlag         = "my-account"
+	notificationIDFlag    = "notification-id"
 	removeFromFlag        = "remove-from"
 	resourceTypeFlag      = "type"
 	statusIDFlag          = "status-id"
 	tagFlag               = "tag"
 	timelineCategoryFlag  = "timeline-category"
-	timelineLimitFlag     = "timeline-limit"
+	limitFlag             = "limit"
 	toAccountFlag         = "to-account"
 )
 
 const (
-	accountResource  = "account"
+	accountResource      = "account"
-	instanceResource = "instance"
+	instanceResource     = "instance"
-	listResource     = "list"
+	listResource         = "list"
-	statusResource   = "status"
+	notificationResource = "notification"
-	timelineResource = "timeline"
+	statusResource       = "status"
+	timelineResource     = "timeline"
 )
 
 type Executor interface {

cmd/enbas/show.go

@@ -19,7 +19,8 @@ type showCommand struct {
 	timelineCategory string
 	listID           string
 	tag              string
-	timelineLimit    int
+	limit    int
+	notificationID   string
 }
 
 func newShowCommand(name, summary string) *showCommand {
@@ -34,7 +35,8 @@ func newShowCommand(name, summary string) *showCommand {
 	command.StringVar(&command.timelineCategory, timelineCategoryFlag, "home", "specify the type of timeline to display (valid values are home, public, list and tag)")
 	command.StringVar(&command.listID, listIDFlag, "", "specify the ID of the list to display")
 	command.StringVar(&command.tag, tagFlag, "", "specify the name of the tag to use")
-	command.IntVar(&command.timelineLimit, timelineLimitFlag, 5, "specify the number of statuses to display")
+	command.IntVar(&command.limit, limitFlag, 20, "specify the limit")
+	command.StringVar(&command.notificationID, notificationIDFlag, "", "specify the ID of the notification to display")
 
 	command.Usage = commandUsageFunc(name, summary, command.FlagSet)
 
@@ -47,11 +49,12 @@ func (c *showCommand) Execute() error {
 	}
 
 	funcMap := map[string]func(*client.Client) error{
-		instanceResource: c.showInstance,
+		instanceResource:     c.showInstance,
-		accountResource:  c.showAccount,
+		accountResource:      c.showAccount,
-		statusResource:   c.showStatus,
+		statusResource:       c.showStatus,
-		timelineResource: c.showTimeline,
+		timelineResource:     c.showTimeline,
-		listResource:     c.showList,
+		listResource:         c.showList,
+		notificationResource: c.showNotification,
 	}
 
 	doFunc, ok := funcMap[c.resourceType]
@@ -129,21 +132,21 @@ func (c *showCommand) showTimeline(gts *client.Client) error {
 
 	switch c.timelineCategory {
 	case "home":
-		timeline, err = gts.GetHomeTimeline(c.timelineLimit)
+		timeline, err = gts.GetHomeTimeline(c.limit)
 	case "public":
-		timeline, err = gts.GetPublicTimeline(c.timelineLimit)
+		timeline, err = gts.GetPublicTimeline(c.limit)
 	case "list":
 		if c.listID == "" {
 			return flagNotSetError{flagText: listIDFlag}
 		}
 
-		timeline, err = gts.GetListTimeline(c.listID, c.timelineLimit)
+		timeline, err = gts.GetListTimeline(c.listID, c.limit)
 	case "tag":
 		if c.tag == "" {
 			return flagNotSetError{flagText: tagFlag}
 		}
 
-		timeline, err = gts.GetTagTimeline(c.tag, c.timelineLimit)
+		timeline, err = gts.GetTagTimeline(c.tag, c.limit)
 	default:
 		return invalidTimelineCategoryError{category: c.timelineCategory}
 	}
@@ -183,6 +186,7 @@ func (c *showCommand) showList(gts *client.Client) error {
 		for i := range accounts {
 			accountMap[accounts[i].ID] = accounts[i].Username
 		}
+
 		list.Accounts = accountMap
 	}
 
@@ -208,3 +212,16 @@ func (c *showCommand) showLists(gts *client.Client) error {
 
 	return nil
 }
+
+func (c *showCommand) showNotification(gts *client.Client) error {
+	notifications, err := gts.GetNotifications(c.limit)
+	if err != nil {
+		return fmt.Errorf("unable to retrieve the notifications; %w", err)
+	}
+
+	for i := range notifications {
+		fmt.Printf("\nNotification ID: %s\n%s", notifications[i].ID, notifications[i].Type)
+	}
+
+	return nil
+}

internal/client/notifications.go

@@ -0,0 +1,29 @@
+package client
+
+import (
+	"fmt"
+	"net/http"
+
+	"codeflow.dananglin.me.uk/apollo/enbas/internal/model"
+)
+
+func (g *Client) GetNotifications(limit int) ([]model.Notification, error) {
+	path := fmt.Sprintf("/api/v1/notifications?limit=%d", limit)
+	url := g.Authentication.Instance + path
+
+	var notifications []model.Notification
+
+	if err := g.sendRequest(http.MethodGet, url, nil, &notifications); err != nil {
+		return nil, fmt.Errorf("received an error after sending the request to get the notifications; %w", err)
+	}
+
+	return notifications, nil
+}
+
+func (g *Client) GetNotification() error {
+	return nil
+}
+
+func (g *Client) DeleteAllNotifications() error {
+	return nil
+}

internal/model/notification.go

@@ -0,0 +1,88 @@
+package model
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+)
+
+type NotificationType int
+
+const (
+	NotificationTypeFollow NotificationType = iota
+	NotificationTypeFollowRequest
+	NotificationTypeMention
+	NotificationTypeReblog
+	NotificationTypeFavourite
+	NotificationTypePoll
+	NotificationTypeStatus
+)
+
+func ParseNotificationType(notificationType string) (NotificationType, error) {
+	switch notificationType {
+	case "follow":
+		return NotificationTypeFollow, nil
+	case "follow_request":
+		return NotificationTypeFollowRequest, nil
+	case "mention":
+		return NotificationTypeMention, nil
+	case "reblog":
+		return NotificationTypeReblog, nil
+	case "favourite":
+		return NotificationTypeFavourite, nil
+	case "poll":
+		return NotificationTypePoll, nil
+	case "status":
+		return NotificationTypeStatus, nil
+	}
+
+	return NotificationType(-1), errors.New("invalid notification type")
+}
+
+func (n NotificationType) String() string {
+	switch n {
+	case NotificationTypeFollow:
+		return "Someone followed you"
+	case NotificationTypeFollowRequest:
+		return "Someone requested to follow you"
+	case NotificationTypeMention:
+		return "Someone mentioned you in their status"
+	case NotificationTypeReblog:
+		return "Someone reposted one of your statuses"
+	case NotificationTypeFavourite:
+		return "Someone liked one of your statuses"
+	case NotificationTypePoll:
+		return "A poll you have participated in has ended"
+	case NotificationTypeStatus:
+		return "Someone you enabled notifications for has posted a status"
+	}
+
+	return ""
+}
+
+func (n *NotificationType) UnmarshalJSON(data []byte) error {
+	var (
+		value string
+		err   error
+	)
+
+	if err = json.Unmarshal(data, &value); err != nil {
+		return fmt.Errorf("unable to unmarshal the data; %w", err)
+	}
+
+	*n, err = ParseNotificationType(value)
+	if err != nil {
+		return fmt.Errorf("unable to parse %q as a notification type; %w", value, err)
+	}
+
+	return nil
+}
+
+type Notification struct {
+	Account   *Account         `json:"account"`
+	CreatedAt time.Time        `json:"created_at"`
+	ID        string           `json:"id"`
+	Status    *Status          `json:"status"`
+	Type      NotificationType `json:"type"`
+}