checkpoint: initial design for notifications; need to think about the way forward

internal/client/notifications.go

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: 2024 Dan Anglin <d.n.i.anglin@gmail.com>
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+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 your notifications: %w", err)
+	}
+
+	return notifications, nil
+}
+
+func (g *Client) GetNotification() error {
+	return nil
+}
+
+func (g *Client) DeleteAllNotifications() error {
+	return nil
+}

internal/executor/const.go

@@ -35,14 +35,15 @@ const (
 	flagType              = "type"
 	flagVisibility        = "visibility"
 
-	resourceAccount   = "account"
-	resourceBlocked   = "blocked"
-	resourceFollowers = "followers"
-	resourceFollowing = "following"
-	resourceInstance  = "instance"
-	resourceList      = "list"
-	resourceNote      = "note"
-	resourceStatus    = "status"
-	resourceTimeline  = "timeline"
-	resourceBookmarks = "bookmarks"
+	resourceAccount      = "account"
+	resourceBlocked      = "blocked"
+	resourceFollowers    = "followers"
+	resourceFollowing    = "following"
+	resourceInstance     = "instance"
+	resourceList         = "list"
+	resourceNote         = "note"
+	resourceStatus       = "status"
+	resourceTimeline     = "timeline"
+	resourceBookmarks    = "bookmarks"
+	resourceNotification = "notification"
 )

internal/executor/show.go

@@ -67,6 +67,7 @@ func (s *ShowExecutor) Execute() error {
 		resourceFollowing: s.showFollowing,
 		resourceBlocked:   s.showBlocked,
 		resourceBookmarks: s.showBookmarks,
+		resourceNotification: s.showNotifications,
 	}
 
 	doFunc, ok := funcMap[s.resourceType]
@@ -329,3 +330,16 @@ func (s *ShowExecutor) showBookmarks(gtsClient *client.Client) error {
 
 	return nil
 }
+
+func (s *ShowExecutor) showNotifications(gts *client.Client) error {
+	notifications, err := gts.GetNotifications(s.limit)
+	if err != nil {
+		return fmt.Errorf("unable to retrieve your notifications: %w", err)
+	}
+
+	for i := range notifications {
+		utilities.Display(notifications[i], *s.topLevelFlags.NoColor)
+	}
+
+	return nil
+}

internal/model/notification.go

@@ -0,0 +1,127 @@
+// SPDX-FileCopyrightText: 2024 Dan Anglin <d.n.i.anglin@gmail.com>
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package model
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"codeflow.dananglin.me.uk/apollo/enbas/internal/utilities"
+)
+
+type NotificationType int
+
+const (
+	NotificationTypeFollow NotificationType = iota
+	NotificationTypeFollowRequest
+	NotificationTypeMention
+	NotificationTypeReblog
+	NotificationTypeFavourite
+	NotificationTypePoll
+	NotificationTypeStatus
+	NotificationTypeUnknown
+)
+
+const (
+	notificationFollow        = "follow"
+	notificationFollowRequest = "follow_request"
+	notificationMention       = "mention"
+	notificationReblog        = "reblog"
+	notificationFavourite     = "favourite"
+	notificationPoll          = "poll"
+	notificationStatus        = "status"
+)
+
+func (n NotificationType) MessageFormat() string {
+	mapped := map[NotificationType]string{
+		NotificationTypeFollow:        "%s followed you",
+		NotificationTypeFollowRequest: "%s has requested to follow you",
+		NotificationTypeMention:       "%s has mentioned you in this status",
+		NotificationTypeReblog:        "%s reposted this status from you",
+		NotificationTypeFavourite:     "%s liked this status from you",
+		NotificationTypePoll:          "A poll from %s that you have voted in has ended",
+		NotificationTypeStatus:        "%s has posted this status",
+	}
+
+	output, ok := mapped[n]
+	if !ok {
+		return "You have received a notification of an unknown type"
+	}
+
+	return output
+}
+
+func ParseNotificationType(value string) (NotificationType, error) {
+	mapped := map[string]NotificationType{
+		notificationFollow:        NotificationTypeFollow,
+		notificationFollowRequest: NotificationTypeFollowRequest,
+		notificationMention:       NotificationTypeMention,
+		notificationReblog:        NotificationTypeReblog,
+		notificationFavourite:     NotificationTypeFavourite,
+		notificationPoll:          NotificationTypePoll,
+		notificationStatus:        NotificationTypeStatus,
+	}
+
+	output, ok := mapped[value]
+	if !ok {
+		return NotificationTypeUnknown, UnknownNotificationError{}
+	}
+
+	return output, nil
+}
+
+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)
+	}
+
+	// Ignore the error if the notification type from another Fediverse service
+	// is not known by enbas. It will be seen as an unknown notification to the user.
+	*n, _ = ParseNotificationType(value)
+
+	return nil
+}
+
+type UnknownNotificationError struct{}
+
+func (e UnknownNotificationError) Error() string {
+	return "unknown notification type"
+}
+
+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"`
+}
+
+func (n Notification) Display(noColor bool) string {
+	var builder strings.Builder
+
+	separator := "────────────────────────────────────────────────────────────────────────────────"
+
+	fmt.Fprintf(&builder,
+		n.Type.MessageFormat(),
+		utilities.DisplayNameFormat(noColor, n.Account.DisplayName)+" (@"+n.Account.Acct+")",
+	)
+
+	if n.Status != nil {
+		builder.WriteString("\n\n" + utilities.DisplayNameFormat(noColor, n.Status.Account.DisplayName) + " (@" + n.Status.Account.Acct + ")\n")
+		builder.WriteString(utilities.WrapLines(utilities.ConvertHTMLToText(n.Status.Content), "\n", 80) + "\n\n")
+		builder.WriteString(utilities.FieldFormat(noColor, "ID:") + " " + n.Status.ID + "\t" + utilities.FieldFormat(noColor, "Created at:") + " " + utilities.FormatTime(n.Status.CreatedAt) + "\n")
+	}
+
+	builder.WriteString(separator + "\n")
+
+	return builder.String()
+}

internal/model/status.go

@@ -83,7 +83,7 @@ type Poll struct {
 
 type PollOption struct {
 	Title      string `json:"title"`
-	VotesCount string `json:"votes_count"`
+	VotesCount int    `json:"votes_count"`
 }
 
 type StatusReblogged struct {