appview/models: move db.Timeline* into models

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

appview/db/timeline.go

···
 
 import (
 	"sort"
-	"time"
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"tangled.org/core/appview/models"
 )
 
-type TimelineEvent struct {
-	*models.Repo
-	*models.Follow
-	*models.Star
-
-	EventAt time.Time
-
-	// optional: populate only if Repo is a fork
-	Source *models.Repo
-
-	// optional: populate only if event is Follow
-	*models.Profile
-	*models.FollowStats
-	*models.FollowStatus
-
-	// optional: populate only if event is Repo
-	IsStarred bool
-	StarCount int64
-}
-
 // TODO: this gathers heterogenous events from different sources and aggregates
 // them in code; if we did this entirely in sql, we could order and limit and paginate easily
-func MakeTimeline(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {
-	var events []TimelineEvent
+func MakeTimeline(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {
+	var events []models.TimelineEvent
 
 	repos, err := getTimelineRepos(e, limit, loggedInUserDid)
 	if err != nil {
···
 	return isStarred, starCount
 }
 
-func getTimelineRepos(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {
+func getTimelineRepos(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {
 	repos, err := GetRepos(e, limit)
 	if err != nil {
 		return nil, err
···
 		return nil, err
 	}
 
-	var events []TimelineEvent
+	var events []models.TimelineEvent
 	for _, r := range repos {
 		var source *models.Repo
 		if r.Source != "" {
···
 
 		isStarred, starCount := getRepoStarInfo(&r, starStatuses)
 
-		events = append(events, TimelineEvent{
+		events = append(events, models.TimelineEvent{
 			Repo:      &r,
 			EventAt:   r.Created,
 			Source:    source,
···
 	return events, nil
 }
 
-func getTimelineStars(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {
+func getTimelineStars(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {
 	stars, err := GetStars(e, limit)
 	if err != nil {
 		return nil, err
···
 		return nil, err
 	}
 
-	var events []TimelineEvent
+	var events []models.TimelineEvent
 	for _, s := range stars {
 		isStarred, starCount := getRepoStarInfo(s.Repo, starStatuses)
 
-		events = append(events, TimelineEvent{
+		events = append(events, models.TimelineEvent{
 			Star:      &s,
 			EventAt:   s.Created,
 			IsStarred: isStarred,
···
 	return events, nil
 }
 
-func getTimelineFollows(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {
+func getTimelineFollows(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {
 	follows, err := GetFollows(e, limit)
 	if err != nil {
 		return nil, err
···
 		}
 	}
 
-	var events []TimelineEvent
+	var events []models.TimelineEvent
 	for _, f := range follows {
 		profile, _ := profiles[f.SubjectDid]
 		followStatMap, _ := followStatMap[f.SubjectDid]
···
 			followStatus = followStatuses[f.SubjectDid]
 		}
 
-		events = append(events, TimelineEvent{
+		events = append(events, models.TimelineEvent{
 			Follow:       &f,
 			Profile:      profile,
 			FollowStats:  &followStatMap,

appview/models/timeline.go

···
+package models
+
+import "time"
+
+type TimelineEvent struct {
+	*Repo
+	*Follow
+	*Star
+
+	EventAt time.Time
+
+	// optional: populate only if Repo is a fork
+	Source *Repo
+
+	// optional: populate only if event is Follow
+	*Profile
+	*FollowStats
+	*FollowStatus
+
+	// optional: populate only if event is Repo
+	IsStarred bool
+	StarCount int64
+}

appview/pages/pages.go

···
 	"tangled.org/core/api/tangled"
 	"tangled.org/core/appview/commitverify"
 	"tangled.org/core/appview/config"
-	"tangled.org/core/appview/db"
 	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages/markup"
···
 
 type TimelineParams struct {
 	LoggedInUser *oauth.User
-	Timeline     []db.TimelineEvent
+	Timeline     []models.TimelineEvent
 	Repos        []models.Repo
 }