appview/notifications: fix pagination

Signed-off-by: oppiliappan <[e-mail]>

appview/db/notifications.go

···
 import (
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
+	"strings"
 	"time"
 
 	"tangled.org/core/appview/models"
···
 	return GetNotificationsPaginated(e, pagination.FirstPage(), filters...)
 }
 
-func (d *DB) GetUnreadNotificationCount(ctx context.Context, userDID string) (int, error) {
-	recipientFilter := FilterEq("recipient_did", userDID)
-	readFilter := FilterEq("read", 0)
+func CountNotifications(e Execer, filters ...filter) (int64, error) {
+	var conditions []string
+	var args []any
+	for _, filter := range filters {
+		conditions = append(conditions, filter.Condition())
+		args = append(args, filter.Arg()...)
+	}
 
-	query := fmt.Sprintf(`
-		SELECT COUNT(*)
-		FROM notifications
-		WHERE %s AND %s
-	`, recipientFilter.Condition(), readFilter.Condition())
+	whereClause := ""
+	if conditions != nil {
+		whereClause = " where " + strings.Join(conditions, " and ")
+	}
 
-	args := append(recipientFilter.Arg(), readFilter.Arg()...)
+	query := fmt.Sprintf(`select count(1) from notifications %s`, whereClause)
+	var count int64
+	err := e.QueryRow(query, args...).Scan(&count)
 
-	var count int
-	err := d.DB.QueryRowContext(ctx, query, args...).Scan(&count)
-	if err != nil {
-		return 0, fmt.Errorf("failed to get unread count: %w", err)
+	if !errors.Is(err, sql.ErrNoRows) && err != nil {
+		return 0, err
 	}
 
 	return count, nil

appview/notifications/notifications.go

···
 package notifications
 
 import (
+	"fmt"
 	"log"
 	"net/http"
 	"strconv"
···
 
 	r.Use(middleware.AuthMiddleware(n.oauth))
 
-	r.Get("/", n.notificationsPage)
+	r.With(middleware.Paginate).Get("/", n.notificationsPage)
 
 	r.Get("/count", n.getUnreadCount)
 	r.Post("/{id}/read", n.markRead)
···
 func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) {
 	userDid := n.oauth.GetDid(r)
 
-	limitStr := r.URL.Query().Get("limit")
-	offsetStr := r.URL.Query().Get("offset")
-
-	limit := 20 // default
-	if limitStr != "" {
-		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {
-			limit = l
-		}
+	page, ok := r.Context().Value("page").(pagination.Page)
+	if !ok {
+		log.Println("failed to get page")
+		page = pagination.FirstPage()
 	}
 
-	offset := 0 // default
-	if offsetStr != "" {
-		if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
-			offset = o
-		}
+	total, err := db.CountNotifications(
+		n.db,
+		db.FilterEq("recipient_did", userDid),
+	)
+	if err != nil {
+		log.Println("failed to get total notifications:", err)
+		n.pages.Error500(w)
+		return
 	}
 
-	page := pagination.Page{Limit: limit + 1, Offset: offset}
-	notifications, err := db.GetNotificationsWithEntities(n.db, page, db.FilterEq("recipient_did", userDid))
+	notifications, err := db.GetNotificationsWithEntities(
+		n.db,
+		page,
+		db.FilterEq("recipient_did", userDid),
+	)
 	if err != nil {
 		log.Println("failed to get notifications:", err)
 		n.pages.Error500(w)
 		return
-	}
-
-	hasMore := len(notifications) > limit
-	if hasMore {
-		notifications = notifications[:limit]
 	}
 
 	err = n.db.MarkAllNotificationsRead(r.Context(), userDid)
···
 		return
 	}
 
-	params := pages.NotificationsParams{
+	fmt.Println(n.pages.Notifications(w, pages.NotificationsParams{
 		LoggedInUser:  user,
 		Notifications: notifications,
 		UnreadCount:   unreadCount,
-		HasMore:       hasMore,
-		NextOffset:    offset + limit,
-		Limit:         limit,
-	}
-
-	err = n.pages.Notifications(w, params)
-	if err != nil {
-		log.Println("failed to load notifs:", err)
-		n.pages.Error500(w)
-		return
-	}
+		Page:          page,
+		Total:         total,
+	}))
 }
 
 func (n *Notifications) getUnreadCount(w http.ResponseWriter, r *http.Request) {
-	userDid := n.oauth.GetDid(r)
-
-	count, err := n.db.GetUnreadNotificationCount(r.Context(), userDid)
+	user := n.oauth.GetUser(r)
+	count, err := db.CountNotifications(
+		n.db,
+		db.FilterEq("recipient_did", user.Did),
+		db.FilterEq("read", 0),
+	)
 	if err != nil {
 		http.Error(w, "Failed to get unread count", http.StatusInternalServerError)
 		return

appview/pages/pages.go

···
 	LoggedInUser  *oauth.User
 	Notifications []*models.NotificationWithEntity
 	UnreadCount   int
-	HasMore       bool
-	NextOffset    int
-	Limit         int
+	Page          pagination.Page
+	Total         int64
 }
 
 func (p *Pages) Notifications(w io.Writer, params NotificationsParams) error {
···
 }
 
 type NotificationCountParams struct {
-	Count int
+	Count int64
 }
 
 func (p *Pages) NotificationCount(w io.Writer, params NotificationCountParams) error {

appview/pages/templates/notifications/list.html

···
     </div>
   </div>
 
-    {{if .Notifications}}
-      <div class="flex flex-col gap-2" id="notifications-list">
-        {{range .Notifications}}
-          {{template "notifications/fragments/item" .}}
-        {{end}}
-      </div>
+  {{if .Notifications}}
+    <div class="flex flex-col gap-2" id="notifications-list">
+      {{range .Notifications}}
+        {{template "notifications/fragments/item" .}}
+      {{end}}
+    </div>
 
-    {{else}}
-      <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">
-        <div class="text-center py-12">
-          <div class="w-16 h-16 mx-auto mb-4 text-gray-300 dark:text-gray-600">
-            {{ i "bell-off" "w-16 h-16" }}
-          </div>
-          <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-2">No notifications</h3>
-          <p class="text-gray-600 dark:text-gray-400">When you receive notifications, they'll appear here.</p>
+  {{else}}
+    <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">
+      <div class="text-center py-12">
+        <div class="w-16 h-16 mx-auto mb-4 text-gray-300 dark:text-gray-600">
+          {{ i "bell-off" "w-16 h-16" }}
         </div>
+        <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-2">No notifications</h3>
+        <p class="text-gray-600 dark:text-gray-400">When you receive notifications, they'll appear here.</p>
       </div>
-    {{end}}
+    </div>
+  {{end}}
+
+  {{ template "pagination" . }}
+{{ end }}
+
+{{ define "pagination" }}
+  <div class="flex justify-end mt-4 gap-2">
+      {{ if gt .Page.Offset 0 }}
+         {{ $prev := .Page.Previous }}
+          <a
+              class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"
+              hx-boost="true"
+              href = "/notifications?offset={{ $prev.Offset }}&limit={{ $prev.Limit }}"
+          >
+              {{ i "chevron-left" "w-4 h-4" }}
+              previous
+          </a>
+      {{ else }}
+          <div></div>
+      {{ end }}
+
+      {{ $next := .Page.Next }}
+      {{ if lt $next.Offset .Total }}
+         {{ $next := .Page.Next }}
+          <a
+              class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"
+              hx-boost="true"
+              href = "/notifications?offset={{ $next.Offset }}&limit={{ $next.Limit }}"
+          >
+              next
+              {{ i "chevron-right" "w-4 h-4" }}
+          </a>
+      {{ end }}
+  </div>
 {{ end }}

appview/pagination/page.go

···
 func FirstPage() Page {
 	return Page{
 		Offset: 0,
-		Limit:  10,
+		Limit:  30,
 	}
 }