appview/notifications: code cleanup for notifier

GetRepo is a specialization for GetRepos which is to be used when the
filters are primary keys.

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

appview/db/notifications.go

···
 	return GetNotificationsPaginated(e, pagination.FirstPage(), filters...)
 }
 
-// GetNotifications retrieves notifications for a user with pagination (legacy method for backward compatibility)
-func (d *DB) GetNotifications(ctx context.Context, userDID string, limit, offset int) ([]*models.Notification, error) {
-	page := pagination.Page{Limit: limit, Offset: offset}
-	return GetNotificationsPaginated(d.DB, page, FilterEq("recipient_did", userDID))
-}
-
-// GetNotificationsWithEntities retrieves notifications with entities for a user with pagination
-func (d *DB) GetNotificationsWithEntities(ctx context.Context, userDID string, limit, offset int) ([]*models.NotificationWithEntity, error) {
-	page := pagination.Page{Limit: limit, Offset: offset}
-	return GetNotificationsWithEntities(d.DB, page, FilterEq("recipient_did", userDID))
-}
-
 func (d *DB) GetUnreadNotificationCount(ctx context.Context, userDID string) (int, error) {
 	recipientFilter := FilterEq("recipient_did", userDID)
 	readFilter := FilterEq("read", 0)

appview/notifications/notifications.go

···
 	"tangled.org/core/appview/middleware"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages"
+	"tangled.org/core/appview/pagination"
 )
 
 type Notifications struct {
···
 		}
 	}
 
-	notifications, err := n.db.GetNotificationsWithEntities(r.Context(), userDid, limit+1, offset)
+	page := pagination.Page{Limit: limit + 1, Offset: offset}
+	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)

appview/notify/db/db.go

···
 
 func (n *databaseNotifier) NewStar(ctx context.Context, star *models.Star) {
 	var err error
-	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(star.RepoAt)))
+	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(star.RepoAt)))
 	if err != nil {
 		log.Printf("NewStar: failed to get repos: %v", err)
 		return
 	}
-	if len(repos) == 0 {
-		log.Printf("NewStar: no repo found for %s", star.RepoAt)
-		return
-	}
-	repo := repos[0]
 
 	// don't notify yourself
 	if repo.Did == star.StarredByDid {
···
 }
 
 func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue) {
-	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(issue.RepoAt)))
+	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(issue.RepoAt)))
 	if err != nil {
 		log.Printf("NewIssue: failed to get repos: %v", err)
 		return
 	}
-	if len(repos) == 0 {
-		log.Printf("NewIssue: no repo found for %s", issue.RepoAt)
-		return
-	}
-	repo := repos[0]
 
 	if repo.Did == issue.Did {
 		return
···
 	}
 	issue := issues[0]
 
-	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(issue.RepoAt)))
+	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(issue.RepoAt)))
 	if err != nil {
 		log.Printf("NewIssueComment: failed to get repos: %v", err)
 		return
 	}
-	if len(repos) == 0 {
-		log.Printf("NewIssueComment: no repo found for %s", issue.RepoAt)
-		return
-	}
-	repo := repos[0]
 
 	recipients := make(map[string]bool)
 
···
 }
 
 func (n *databaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {
-	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(pull.RepoAt)))
+	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))
 	if err != nil {
 		log.Printf("NewPull: failed to get repos: %v", err)
 		return
 	}
-	if len(repos) == 0 {
-		log.Printf("NewPull: no repo found for %s", pull.RepoAt)
-		return
-	}
-	repo := repos[0]
 
 	if repo.Did == pull.OwnerDid {
 		return
···
 	}
 	pull := pulls[0]
 
-	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", comment.RepoAt))
+	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", comment.RepoAt))
 	if err != nil {
 		log.Printf("NewPullComment: failed to get repos: %v", err)
 		return
 	}
-	if len(repos) == 0 {
-		log.Printf("NewPullComment: no repo found for %s", comment.RepoAt)
-		return
-	}
-	repo := repos[0]
 
 	recipients := make(map[string]bool)
 
···
 
 func (n *databaseNotifier) NewIssueClosed(ctx context.Context, issue *models.Issue) {
 	// Get repo details
-	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(issue.RepoAt)))
+	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(issue.RepoAt)))
 	if err != nil {
 		log.Printf("NewIssueClosed: failed to get repos: %v", err)
 		return
 	}
-	if len(repos) == 0 {
-		log.Printf("NewIssueClosed: no repo found for %s", issue.RepoAt)
-		return
-	}
-	repo := repos[0]
 
 	// Don't notify yourself
 	if repo.Did == issue.Did {
···
 
 func (n *databaseNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {
 	// Get repo details
-	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(pull.RepoAt)))
+	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))
 	if err != nil {
 		log.Printf("NewPullMerged: failed to get repos: %v", err)
 		return
 	}
-	if len(repos) == 0 {
-		log.Printf("NewPullMerged: no repo found for %s", pull.RepoAt)
-		return
-	}
-	repo := repos[0]
 
 	// Don't notify yourself
 	if repo.Did == pull.OwnerDid {
···
 
 func (n *databaseNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {
 	// Get repo details
-	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(pull.RepoAt)))
+	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))
 	if err != nil {
 		log.Printf("NewPullClosed: failed to get repos: %v", err)
 		return
 	}
-	if len(repos) == 0 {
-		log.Printf("NewPullClosed: no repo found for %s", pull.RepoAt)
-		return
-	}
-	repo := repos[0]
 
 	// Don't notify yourself
 	if repo.Did == pull.OwnerDid {