commit ebbe9274801015a01c043528b34b80bc901fe65e · nel.pet/core

+11 -32

appview/db/timeline.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"sort"

     

       5
       -
       	"time"

     

       6
        
       

     

       7
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
        
       	"tangled.org/core/appview/models"

     

       9
        
       )

     

       10
        
       

     

       11
       -
       type TimelineEvent struct {

     

       12
       -
       	*models.Repo

     

       13
       -
       	*models.Follow

     

       14
       -
       	*models.Star

     

       15
       -
       

     

       16
       -
       	EventAt time.Time

     

       17
       -
       

     

       18
       -
       	// optional: populate only if Repo is a fork

     

       19
       -
       	Source *models.Repo

     

       20
       -
       

     

       21
       -
       	// optional: populate only if event is Follow

     

       22
       -
       	*models.Profile

     

       23
       -
       	*models.FollowStats

     

       24
       -
       	*models.FollowStatus

     

       25
       -
       

     

       26
       -
       	// optional: populate only if event is Repo

     

       27
       -
       	IsStarred bool

     

       28
       -
       	StarCount int64

     

       29
       -
       }

     

       30
       -
       

     

       31
        
       // TODO: this gathers heterogenous events from different sources and aggregates

     

       32
        
       // them in code; if we did this entirely in sql, we could order and limit and paginate easily

     

       33
       -
       func MakeTimeline(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {

     

       34
       -
       	var events []TimelineEvent

     

       35
        
       

     

       36
        
       	repos, err := getTimelineRepos(e, limit, loggedInUserDid)

     

       37
        
       	if err != nil {

     
···

       91
        
       	return isStarred, starCount

     

       92
        
       }

     

       93
        
       

     

       94
       -
       func getTimelineRepos(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {

     

       95
        
       	repos, err := GetRepos(e, limit)

     

       96
        
       	if err != nil {

     

       97
        
       		return nil, err

     
···

       123
        
       		return nil, err

     

       124
        
       	}

     

       125
        
       

     

       126
       -
       	var events []TimelineEvent

     

       127
        
       	for _, r := range repos {

     

       128
        
       		var source *models.Repo

     

       129
        
       		if r.Source != "" {

     
···

       134
        
       

     

       135
        
       		isStarred, starCount := getRepoStarInfo(&r, starStatuses)

     

       136
        
       

     

       137
       -
       		events = append(events, TimelineEvent{

     

       138
        
       			Repo:      &r,

     

       139
        
       			EventAt:   r.Created,

     

       140
        
       			Source:    source,

     
···

       146
        
       	return events, nil

     

       147
        
       }

     

       148
        
       

     

       149
       -
       func getTimelineStars(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {

     

       150
        
       	stars, err := GetStars(e, limit)

     

       151
        
       	if err != nil {

     

       152
        
       		return nil, err

     
···

       172
        
       		return nil, err

     

       173
        
       	}

     

       174
        
       

     

       175
       -
       	var events []TimelineEvent

     

       176
        
       	for _, s := range stars {

     

       177
        
       		isStarred, starCount := getRepoStarInfo(s.Repo, starStatuses)

     

       178
        
       

     

       179
       -
       		events = append(events, TimelineEvent{

     

       180
        
       			Star:      &s,

     

       181
        
       			EventAt:   s.Created,

     

       182
        
       			IsStarred: isStarred,

     
···

       187
        
       	return events, nil

     

       188
        
       }

     

       189
        
       

     

       190
       -
       func getTimelineFollows(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {

     

       191
        
       	follows, err := GetFollows(e, limit)

     

       192
        
       	if err != nil {

     

       193
        
       		return nil, err

     
···

       220
        
       		}

     

       221
        
       	}

     

       222
        
       

     

       223
       -
       	var events []TimelineEvent

     

       224
        
       	for _, f := range follows {

     

       225
        
       		profile, _ := profiles[f.SubjectDid]

     

       226
        
       		followStatMap, _ := followStatMap[f.SubjectDid]

     
···

       230
        
       			followStatus = followStatuses[f.SubjectDid]

     

       231
        
       		}

     

       232
        
       

     

       233
       -
       		events = append(events, TimelineEvent{

     

       234
        
       			Follow:       &f,

     

       235
        
       			Profile:      profile,

     

       236
        
       			FollowStats:  &followStatMap,

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"sort"

     

       0
        
       
     

       5
        
       

     

       6
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
        
       	"tangled.org/core/appview/models"

     

       8
        
       )

     

       9
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       // TODO: this gathers heterogenous events from different sources and aggregates

     

       11
        
       // them in code; if we did this entirely in sql, we could order and limit and paginate easily

     

       12
       +
       func MakeTimeline(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {

     

       13
       +
       	var events []models.TimelineEvent

     

       14
        
       

     

       15
        
       	repos, err := getTimelineRepos(e, limit, loggedInUserDid)

     

       16
        
       	if err != nil {

     
···

       70
        
       	return isStarred, starCount

     

       71
        
       }

     

       72
        
       

     

       73
       +
       func getTimelineRepos(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {

     

       74
        
       	repos, err := GetRepos(e, limit)

     

       75
        
       	if err != nil {

     

       76
        
       		return nil, err

     
···

       102
        
       		return nil, err

     

       103
        
       	}

     

       104
        
       

     

       105
       +
       	var events []models.TimelineEvent

     

       106
        
       	for _, r := range repos {

     

       107
        
       		var source *models.Repo

     

       108
        
       		if r.Source != "" {

     
···

       113
        
       

     

       114
        
       		isStarred, starCount := getRepoStarInfo(&r, starStatuses)

     

       115
        
       

     

       116
       +
       		events = append(events, models.TimelineEvent{

     

       117
        
       			Repo:      &r,

     

       118
        
       			EventAt:   r.Created,

     

       119
        
       			Source:    source,

     
···

       125
        
       	return events, nil

     

       126
        
       }

     

       127
        
       

     

       128
       +
       func getTimelineStars(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {

     

       129
        
       	stars, err := GetStars(e, limit)

     

       130
        
       	if err != nil {

     

       131
        
       		return nil, err

     
···

       151
        
       		return nil, err

     

       152
        
       	}

     

       153
        
       

     

       154
       +
       	var events []models.TimelineEvent

     

       155
        
       	for _, s := range stars {

     

       156
        
       		isStarred, starCount := getRepoStarInfo(s.Repo, starStatuses)

     

       157
        
       

     

       158
       +
       		events = append(events, models.TimelineEvent{

     

       159
        
       			Star:      &s,

     

       160
        
       			EventAt:   s.Created,

     

       161
        
       			IsStarred: isStarred,

     
···

       166
        
       	return events, nil

     

       167
        
       }

     

       168
        
       

     

       169
       +
       func getTimelineFollows(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {

     

       170
        
       	follows, err := GetFollows(e, limit)

     

       171
        
       	if err != nil {

     

       172
        
       		return nil, err

     
···

       199
        
       		}

     

       200
        
       	}

     

       201
        
       

     

       202
       +
       	var events []models.TimelineEvent

     

       203
        
       	for _, f := range follows {

     

       204
        
       		profile, _ := profiles[f.SubjectDid]

     

       205
        
       		followStatMap, _ := followStatMap[f.SubjectDid]

     
···

       209
        
       			followStatus = followStatuses[f.SubjectDid]

     

       210
        
       		}

     

       211
        
       

     

       212
       +
       		events = append(events, models.TimelineEvent{

     

       213
        
       			Follow:       &f,

     

       214
        
       			Profile:      profile,

     

       215
        
       			FollowStats:  &followStatMap,

+23

appview/models/timeline.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import "time"

     

       4
       +
       

     

       5
       +
       type TimelineEvent struct {

     

       6
       +
       	*Repo

     

       7
       +
       	*Follow

     

       8
       +
       	*Star

     

       9
       +
       

     

       10
       +
       	EventAt time.Time

     

       11
       +
       

     

       12
       +
       	// optional: populate only if Repo is a fork

     

       13
       +
       	Source *Repo

     

       14
       +
       

     

       15
       +
       	// optional: populate only if event is Follow

     

       16
       +
       	*Profile

     

       17
       +
       	*FollowStats

     

       18
       +
       	*FollowStatus

     

       19
       +
       

     

       20
       +
       	// optional: populate only if event is Repo

     

       21
       +
       	IsStarred bool

     

       22
       +
       	StarCount int64

     

       23
       +
       }

+1 -2

appview/pages/pages.go

···

       19
        
       	"tangled.org/core/api/tangled"

     

       20
        
       	"tangled.org/core/appview/commitverify"

     

       21
        
       	"tangled.org/core/appview/config"

     

       22
       -
       	"tangled.org/core/appview/db"

     

       23
        
       	"tangled.org/core/appview/models"

     

       24
        
       	"tangled.org/core/appview/oauth"

     

       25
        
       	"tangled.org/core/appview/pages/markup"

     
···

       283
        
       

     

       284
        
       type TimelineParams struct {

     

       285
        
       	LoggedInUser *oauth.User

     

       286
       -
       	Timeline     []db.TimelineEvent

     

       287
        
       	Repos        []models.Repo

     

       288
        
       }

     

       289

···

       19
        
       	"tangled.org/core/api/tangled"

     

       20
        
       	"tangled.org/core/appview/commitverify"

     

       21
        
       	"tangled.org/core/appview/config"

     

       0
        
       
     

       22
        
       	"tangled.org/core/appview/models"

     

       23
        
       	"tangled.org/core/appview/oauth"

     

       24
        
       	"tangled.org/core/appview/pages/markup"

     
···

       282
        
       

     

       283
        
       type TimelineParams struct {

     

       284
        
       	LoggedInUser *oauth.User

     

       285
       +
       	Timeline     []models.TimelineEvent

     

       286
        
       	Repos        []models.Repo

     

       287
        
       }

     

       288